@tendrilapp/cli 0.1.31 → 0.1.32

package/dist/tendril.js

@@ -1297,9 +1297,396 @@ var init_session = __esm({
   }
 });
 
-// packages/figma/src/recording/roles.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+// packages/figma/src/recording/compose.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, statSync } from "node:fs";
 import path2 from "node:path";
+import { z as z5 } from "zod";
+function buildComposeIndex(roots, depth = 3) {
+  const found = [];
+  const walk2 = (dir, remaining) => {
+    if (existsSync2(path2.join(dir, "recording-set.json"))) {
+      found.push(dir);
+      return;
+    }
+    if (remaining === 0) return;
+    let entries2;
+    try {
+      entries2 = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const e of entries2) {
+      if (e === "node_modules" || e.startsWith(".")) continue;
+      const full = path2.join(dir, e);
+      try {
+        if (statSync(full).isDirectory()) walk2(full, remaining - 1);
+      } catch {
+      }
+    }
+  };
+  for (const r of roots) walk2(path2.resolve(r), depth);
+  const seen = /* @__PURE__ */ new Set();
+  const uniqueDirs = found.filter((d) => {
+    const key = path2.resolve(d);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  const entries = [];
+  for (const dir of uniqueDirs) {
+    let manifest;
+    try {
+      manifest = loadManifest(dir);
+    } catch {
+      continue;
+    }
+    const ownIdsByRep = /* @__PURE__ */ new Map();
+    const ownIds = /* @__PURE__ */ new Set();
+    const variantNodeIds = /* @__PURE__ */ new Set();
+    const repSlugByVariantNode = /* @__PURE__ */ new Map();
+    for (const rep of manifest.reps) {
+      variantNodeIds.add(rep.nodeId);
+      repSlugByVariantNode.set(rep.nodeId, rep.slug);
+      const metaFile = path2.join(dir, rep.slug, "get_metadata.json");
+      if (!existsSync2(metaFile)) continue;
+      try {
+        const text = envelopeTextContent(JSON.parse(readFileSync2(metaFile, "utf8")));
+        const ids = /* @__PURE__ */ new Set();
+        const collect = (n) => {
+          if (n.id !== "") ids.add(n.id);
+          for (const c of n.children) collect(c);
+        };
+        for (const root of parseMetadataForest(text).roots) collect(root);
+        ownIdsByRep.set(rep.slug, ids);
+        for (const id of ids) ownIds.add(id);
+      } catch {
+      }
+    }
+    entries.push({
+      dir,
+      displayName: manifest.component,
+      ...manifest.figmaFile !== void 0 ? { figmaFile: manifest.figmaFile } : {},
+      ...manifest.componentSetNode !== void 0 ? { componentSetNode: manifest.componentSetNode } : {},
+      ...manifest.figmaComponentName !== void 0 ? { figmaComponentName: manifest.figmaComponentName } : {},
+      variantNodeIds,
+      repSlugByVariantNode,
+      ownIdsByRep,
+      ownIds
+    });
+  }
+  return entries;
+}
+function sameComponent(a, b) {
+  if (a.figmaFile !== void 0 && b.figmaFile !== void 0 && a.figmaFile !== b.figmaFile) return false;
+  if (a.componentSetNode !== void 0 && a.componentSetNode === b.componentSetNode && a.figmaFile === b.figmaFile) return true;
+  for (const id of a.variantNodeIds) if (b.variantNodeIds.has(id)) return true;
+  return false;
+}
+function emissionTails(setDir, repSlug) {
+  const file = path2.join(setDir, repSlug, "get_design_context.json");
+  if (!existsSync2(file)) return /* @__PURE__ */ new Map();
+  let text;
+  try {
+    text = envelopeTextContent(JSON.parse(readFileSync2(file, "utf8")));
+  } catch {
+    return /* @__PURE__ */ new Map();
+  }
+  const cut = text.search(FOOTER);
+  if (cut !== -1) text = text.slice(0, cut);
+  const byHead = /* @__PURE__ */ new Map();
+  for (const m of text.matchAll(/data-node-id="I([^"]+)"/g)) {
+    const segs = m[1].split(";");
+    const head = segs[0];
+    if (!byHead.has(head)) byHead.set(head, /* @__PURE__ */ new Map());
+    const tails = byHead.get(head);
+    segs.slice(1).forEach((tail, i) => {
+      const d = i + 1;
+      if (!tails.has(tail) || tails.get(tail) > d) tails.set(tail, d);
+    });
+  }
+  return byHead;
+}
+function hostInstances(setDir, repSlug) {
+  const metaFile = path2.join(setDir, repSlug, "get_metadata.json");
+  if (!existsSync2(metaFile)) return [];
+  try {
+    const text = envelopeTextContent(JSON.parse(readFileSync2(metaFile, "utf8")));
+    const out = [];
+    const walk2 = (n) => {
+      if (n.type === "INSTANCE") out.push({ id: n.id, name: n.name });
+      for (const c of n.children) walk2(c);
+    };
+    for (const root of parseMetadataForest(text).roots) walk2(root);
+    return out;
+  } catch {
+    return [];
+  }
+}
+function composeReport(index) {
+  const edges = [];
+  for (const host of index) {
+    for (const [variantNodeId, slug] of host.repSlugByVariantNode) {
+      void variantNodeId;
+      const instances = hostInstances(host.dir, slug);
+      if (instances.length === 0) continue;
+      const tailsByHead = emissionTails(host.dir, slug);
+      for (const inst of instances) {
+        const tails = tailsByHead.get(inst.id) ?? /* @__PURE__ */ new Map();
+        const disclosures = [];
+        const refused = [];
+        const idCands = index.filter((c) => {
+          if (c.dir === host.dir || sameComponent(c, host)) return false;
+          for (const t of tails.keys()) if (c.ownIds.has(t)) return true;
+          return false;
+        });
+        const survivors = [];
+        for (const c of idCands) {
+          if (host.figmaFile !== void 0 && c.figmaFile !== void 0 && c.figmaFile !== host.figmaFile) {
+            disclosures.push(
+              `LIBRARY-EDGE (not auto-joined): id evidence points at ${kitLabel(c)} recorded from a DIFFERENT file \u2014 a genuine cross-file/library relationship the same-file rule refuses; the future cross-file ADR owns this class`
+            );
+            refused.push(c);
+            continue;
+          }
+          survivors.push(c);
+        }
+        const groups = [];
+        for (const c of survivors) {
+          const g = groups.find((grp) => grp.some((m) => sameComponent(m, c)));
+          if (g) g.push(c);
+          else groups.push([c]);
+        }
+        const eligible = [];
+        for (const g of groups) {
+          const uncaptured = [host.figmaFile === void 0 ? "the host set" : void 0, ...g.map((m) => m.figmaFile === void 0 ? path2.basename(m.dir) : void 0)].filter(
+            (x) => x !== void 0
+          );
+          if (uncaptured.length > 0) {
+            disclosures.push(`identity unproven: file identity is not captured on ${uncaptured.join(", ")} (recorded before slice 1) \u2014 the join rests on id evidence alone`);
+          }
+          eligible.push(g);
+        }
+        const nameProps = index.filter((c) => {
+          if (c.dir === host.dir || sameComponent(c, host)) return false;
+          if (refused.some((r) => r.dir === c.dir || sameComponent(r, c))) return false;
+          const identityName = c.figmaComponentName ?? c.displayName;
+          return norm(identityName) === norm(inst.name);
+        });
+        if (eligible.length === 0) {
+          if (nameProps.length > 0) {
+            edges.push({
+              hostSet: host.dir,
+              hostRep: slug,
+              instanceId: inst.id,
+              instanceName: inst.name,
+              kind: "proposal",
+              partners: nameProps.map((p) => ({ dir: p.dir, displayName: p.displayName, ...p.figmaFile !== void 0 ? { figmaFile: p.figmaFile } : {} })),
+              disclosures: [
+                ...disclosures,
+                `NAME-ONLY proposal \u2014 identity unproven, name evidence never auto-joins: instance "${inst.name}" names ${nameProps.map(kitLabel).join(" / ")}; confirm to compose (a later slice), or ignore`
+              ]
+            });
+          } else if (disclosures.length > 0) {
+            edges.push({ hostSet: host.dir, hostRep: slug, instanceId: inst.id, instanceName: inst.name, kind: "external", partners: [], disclosures });
+          }
+          continue;
+        }
+        if (eligible.length > 1) {
+          edges.push({
+            hostSet: host.dir,
+            hostRep: slug,
+            instanceId: inst.id,
+            instanceName: inst.name,
+            kind: "ask",
+            partners: eligible.flat().map((p) => ({ dir: p.dir, displayName: p.displayName, ...p.figmaFile !== void 0 ? { figmaFile: p.figmaFile } : {} })),
+            disclosures: [...disclosures, `AMBIGUOUS: id evidence reaches ${eligible.length} distinct components \u2014 a human picks, once, recorded (never guessed)`]
+          });
+          continue;
+        }
+        const group = eligible[0];
+        const ownedDepths = [];
+        for (const [t, d] of tails) if (group.some((m) => m.ownIds.has(t))) ownedDepths.push(d);
+        const substitution = ownedDepths.length > 0 && ownedDepths.every((d) => d === 1);
+        const poseVariants = /* @__PURE__ */ new Set();
+        for (const m of group) {
+          for (const [t, d] of tails) {
+            if (d !== 1 || !m.ownIds.has(t)) continue;
+            for (const [slug2, ids] of m.ownIdsByRep) {
+              if (!ids.has(t)) continue;
+              const variant = [...m.repSlugByVariantNode].find(([, s]) => s === slug2)?.[0];
+              if (variant !== void 0) poseVariants.add(variant);
+            }
+          }
+        }
+        for (const p of nameProps) {
+          if (!group.some((m) => sameComponent(m, p))) {
+            disclosures.push(`NAME DISAGREES: instance name "${inst.name}" matches ${kitLabel(p)} while id evidence joins ${kitLabel(group[0])} \u2014 if the id join looks wrong, this is the signal`);
+          }
+        }
+        if (!substitution) {
+          edges.push({
+            hostSet: host.dir,
+            hostRep: slug,
+            instanceId: inst.id,
+            instanceName: inst.name,
+            kind: "nested",
+            partners: group.map((p) => ({ dir: p.dir, displayName: p.displayName, ...p.figmaFile !== void 0 ? { figmaFile: p.figmaFile } : {} })),
+            disclosures: [...disclosures, "GENUINE-NESTED: id evidence sits below depth 1 (through an intermediate instance) \u2014 a real relationship, never a substitution target"]
+          });
+          continue;
+        }
+        if (poseVariants.size > 1) {
+          edges.push({
+            hostSet: host.dir,
+            hostRep: slug,
+            instanceId: inst.id,
+            instanceName: inst.name,
+            kind: "ask",
+            partners: group.map((p) => ({ dir: p.dir, displayName: p.displayName, ...p.figmaFile !== void 0 ? { figmaFile: p.figmaFile } : {} })),
+            disclosures: [...disclosures, `POSE-AMBIGUOUS: depth-1 evidence spans ${poseVariants.size} distinct variants \u2014 a human picks`]
+          });
+          continue;
+        }
+        const variantNode = [...poseVariants][0];
+        edges.push({
+          hostSet: host.dir,
+          hostRep: slug,
+          instanceId: inst.id,
+          instanceName: inst.name,
+          kind: "substitution",
+          partners: group.map((p) => ({ dir: p.dir, displayName: p.displayName, ...p.figmaFile !== void 0 ? { figmaFile: p.figmaFile } : {} })),
+          pose: {
+            variantNodeId: variantNode,
+            reps: group.filter((m) => m.repSlugByVariantNode.has(variantNode)).map((m) => ({ dir: m.dir, slug: m.repSlugByVariantNode.get(variantNode) }))
+          },
+          disclosures: [
+            ...disclosures,
+            "substitution-grade: every owned tail at depth 1; pixel-neutrality is NOT asserted here \u2014 instance overrides are measured real, and the score-time check (a later slice) is the judge"
+          ]
+        });
+      }
+    }
+  }
+  return edges;
+}
+function confirmedCompositionStatus(hostSet) {
+  const manifestFile = path2.join(hostSet, "recording-set.json");
+  if (!existsSync2(manifestFile)) return { rows: [] };
+  let rawEntries;
+  try {
+    const parsed = JSON.parse(readFileSync2(manifestFile, "utf8"));
+    rawEntries = Array.isArray(parsed["compositions"]) ? parsed["compositions"] : [];
+  } catch {
+    return { rows: [], malformed: "the recording-set manifest is not readable JSON" };
+  }
+  const entries = [];
+  const malformedEntries = [];
+  for (let i = 0; i < rawEntries.length; i++) {
+    const parsed = CompositionEntrySchema.safeParse(rawEntries[i]);
+    if (!parsed.success) {
+      malformedEntries.push(`compositions[${i}] is not a valid v1 entry (${parsed.error.issues[0]?.message ?? "invalid"})`);
+      continue;
+    }
+    entries.push(parsed.data);
+  }
+  const confirmed = entries.filter((e) => e.status === "confirmed");
+  const rows = [];
+  for (const entry of confirmed) {
+    const partnerRels = Object.keys(entry.partner.manifestSha256).map(fromStoredRel);
+    const partnerDirs = partnerRels.map((rel) => path2.resolve(hostSet, rel));
+    const entryKey = fromStoredRel(entry.partner.key);
+    const affectedReps = [...new Set(entry.instances.map((i) => i.hostRep))];
+    const remediation = `re-run \`tendril compose --set ${hostSet}\` after repairing`;
+    const missing = partnerDirs.filter((d) => !existsSync2(path2.join(d, "recording-set.json")));
+    if (missing.length > 0) {
+      rows.push({
+        key: entryKey,
+        displayName: entry.partner.displayName,
+        status: "partner-missing",
+        instances: entry.instances,
+        affectedReps,
+        detail: `confirmed partner set(s) not found: ${missing.map((d) => toPosixRel(path2.relative(hostSet, d))).join(", ")} \u2014 the decision names recordings that are not there; ${remediation}`
+      });
+      continue;
+    }
+    let stale = false;
+    let unreadable;
+    for (const rel of partnerRels) {
+      const file = path2.join(path2.resolve(hostSet, rel), "recording-set.json");
+      try {
+        const bytes = readFileSync2(file);
+        loadManifest(path2.resolve(hostSet, rel));
+        const storedSha = entry.partner.manifestSha256[Object.keys(entry.partner.manifestSha256).find((k) => fromStoredRel(k) === rel)];
+        if (createHashHex(bytes) !== storedSha) stale = true;
+      } catch (err) {
+        unreadable = `partner ${rel} is present but not readable as a recording set (${err instanceof Error ? err.message.split("\n")[0] : String(err)})`;
+        break;
+      }
+    }
+    if (unreadable !== void 0) {
+      rows.push({
+        key: entryKey,
+        displayName: entry.partner.displayName,
+        status: "partner-unreadable",
+        instances: entry.instances,
+        affectedReps,
+        detail: `INSTRUMENT FAILURE, not an evidence verdict: ${unreadable} \u2014 the backstop could not re-derive; ${remediation}`
+      });
+      continue;
+    }
+    const edges = composeReport(buildComposeIndex([hostSet, ...partnerDirs]));
+    const supportedInstances = /* @__PURE__ */ new Map();
+    for (const e of edges) {
+      if (e.hostSet !== path2.resolve(hostSet) || e.kind !== "substitution" || e.pose === void 0) continue;
+      if (pairKeyFor(path2.resolve(hostSet), e.partners.map((p) => p.dir)) !== entryKey) continue;
+      supportedInstances.set(`${e.hostRep}\0${e.instanceId}`, e.pose.variantNodeId);
+    }
+    const unsupported = entry.instances.filter((i) => supportedInstances.get(`${i.hostRep}\0${i.instanceId}`) !== i.poseVariantNodeId);
+    const ok = unsupported.length === 0;
+    rows.push({
+      key: entryKey,
+      displayName: entry.partner.displayName,
+      status: ok ? stale ? "stale-supported" : "supported" : stale ? "stale-unsupported" : "unsupported",
+      instances: entry.instances,
+      affectedReps: ok ? [] : [...new Set(unsupported.map((i) => i.hostRep))],
+      detail: ok ? stale ? "the partner manifest changed since the decision (pinned bytes differ) \u2014 the CURRENT recordings still support every confirmed edge" : "the recordings support every confirmed edge (identity, rep attribution and pose re-derived)" : `${unsupported.length} confirmed instance(s) are NOT supported by the current recordings (${unsupported.map((i) => `${i.hostRep}/${i.instanceId}`).join(", ")}) \u2014 a confirmed composition the evidence does not derive; ${remediation}`
+    });
+  }
+  return { rows, ...malformedEntries.length > 0 ? { malformed: malformedEntries.join("; ") } : {} };
+}
+function createHashHex(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+var CompositionEntrySchema, norm, FOOTER, kitLabel, toPosixRel, fromStoredRel, pairKeyFor;
+var init_compose = __esm({
+  "packages/figma/src/recording/compose.ts"() {
+    "use strict";
+    init_session();
+    init_normalize();
+    CompositionEntrySchema = z5.object({
+      v: z5.literal(1),
+      partner: z5.object({
+        key: z5.string().min(1),
+        displayName: z5.string(),
+        figmaFile: z5.string().optional(),
+        manifestSha256: z5.record(z5.string(), z5.string().regex(/^[0-9a-f]{64}$/))
+      }),
+      instances: z5.array(z5.object({ hostRep: z5.string(), instanceId: z5.string(), poseVariantNodeId: z5.string() })).min(1),
+      status: z5.enum(["confirmed", "declined"])
+    });
+    norm = (s) => s.toLowerCase().replace(/\s+/g, " ").trim();
+    FOOTER = /Node ids have been added to the code as data attributes/i;
+    kitLabel = (e) => `${e.displayName} [${path2.basename(e.dir)}${e.figmaFile !== void 0 ? `, file ${e.figmaFile}` : ", file identity NOT captured"}]`;
+    toPosixRel = (rel) => rel.split(path2.sep).join("/");
+    fromStoredRel = (rel) => rel.replace(/\\/g, "/");
+    pairKeyFor = (hostSet, dirs) => dirs.map((d) => toPosixRel(path2.relative(hostSet, d))).sort().join("+");
+  }
+});
+
+// packages/figma/src/recording/roles.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import path3 from "node:path";
 function emissionIdSets(emission) {
   const own = /* @__PURE__ */ new Set();
   const referenced = /* @__PURE__ */ new Set();
@@ -1318,10 +1705,10 @@ function emissionIdSets(emission) {
 }
 function deriveRoles(setDir, manifest) {
   const m = manifest ?? loadManifest(setDir);
-  const reps = m.reps.filter((r) => existsSync2(path2.join(setDir, r.slug, "get_design_context.json")));
+  const reps = m.reps.filter((r) => existsSync3(path3.join(setDir, r.slug, "get_design_context.json")));
   const sets = /* @__PURE__ */ new Map();
   for (const rep of reps) {
-    const env = JSON.parse(readFileSync2(path2.join(setDir, rep.slug, "get_design_context.json"), "utf8"));
+    const env = JSON.parse(readFileSync3(path3.join(setDir, rep.slug, "get_design_context.json"), "utf8"));
     const ids = emissionIdSets(env.content.map((c) => c.text ?? "").join("\n"));
     ids.own.add(rep.nodeId);
     sets.set(rep.slug, ids);
@@ -1389,6 +1776,7 @@ var init_src = __esm({
     init_provided_recording();
     init_axis_defaults();
     init_plan();
+    init_compose();
     init_session();
     init_envelope_content();
     init_roles();
@@ -1399,8 +1787,8 @@ var init_src = __esm({
 function variableNameToPath(name) {
   return name.split("/").map(canonicalCssIdentPart).filter((part) => part.length > 0);
 }
-function tokenPathToCssVar(path41) {
-  return `--${path41.join("-")}`;
+function tokenPathToCssVar(path44) {
+  return `--${path44.join("-")}`;
 }
 function toDtcgToken(variable, defaultMode) {
   const modes = Object.keys(variable.valuesByMode);
@@ -1444,11 +1832,11 @@ function toDtcgToken(variable, defaultMode) {
 }
 function mapVariablesToDtcg(variables, defaultMode = "light") {
   const entries = variables.map((variable) => {
-    const path41 = variableNameToPath(variable.name);
-    if (path41.length === 0) {
+    const path44 = variableNameToPath(variable.name);
+    if (path44.length === 0) {
       throw new DtcgMappingError("empty-name", `Figma variable ${variable.id} has an empty name`);
     }
-    return { variable, path: path41 };
+    return { variable, path: path44 };
   });
   const groupPrefixes = /* @__PURE__ */ new Set();
   for (const e of entries) {
@@ -1469,21 +1857,21 @@ function mapVariablesToDtcg(variables, defaultMode = "light") {
   }
   const tokens = {};
   const flat = [];
-  for (const { variable, path: path41 } of entries) {
+  for (const { variable, path: path44 } of entries) {
     const token = toDtcgToken(variable, defaultMode);
     let group = tokens;
-    for (const segment of path41.slice(0, -1)) {
+    for (const segment of path44.slice(0, -1)) {
       const existing = group[segment];
       group = existing ?? (group[segment] = {});
     }
-    const leaf = path41[path41.length - 1];
+    const leaf = path44[path44.length - 1];
     if (group[leaf] !== void 0) {
-      throw new DtcgMappingError("duplicate-path", `Duplicate token path "${path41.join(".")}" (variable ${variable.id})`);
+      throw new DtcgMappingError("duplicate-path", `Duplicate token path "${path44.join(".")}" (variable ${variable.id})`);
     }
     group[leaf] = token;
     flat.push({
-      path: path41.join("."),
-      cssVar: tokenPathToCssVar(path41),
+      path: path44.join("."),
+      cssVar: tokenPathToCssVar(path44),
       type: token.$type,
       value: token.$value
     });
@@ -1672,9 +2060,9 @@ function boundId(value) {
   return isObject(value) && typeof value["boundVariableId"] === "string" ? value["boundVariableId"] : void 0;
 }
 function resolveBinding(ctx, id) {
-  const path41 = ctx.pathById.get(id);
-  if (path41 === void 0) ctx.unresolved.add(id);
-  return path41;
+  const path44 = ctx.pathById.get(id);
+  if (path44 === void 0) ctx.unresolved.add(id);
+  return path44;
 }
 function parseVariantProps(name) {
   if (!name.includes("=")) return void 0;
@@ -1709,8 +2097,8 @@ function walk(ctx, raw) {
       if (!isObject(paint) || paint["visible"] === false) continue;
       const id = boundId(paint);
       if (id !== void 0) {
-        const path41 = resolveBinding(ctx, id);
-        if (path41 !== void 0) tokens.add(path41);
+        const path44 = resolveBinding(ctx, id);
+        if (path44 !== void 0) tokens.add(path44);
       } else if (typeof paint["color"] === "string") {
         ctx.hardcoded.push({ node: name, property, value: paint["color"] });
       }
@@ -1718,8 +2106,8 @@ function walk(ctx, raw) {
   }
   const radiusId = boundId(raw["cornerRadius"]);
   if (radiusId !== void 0) {
-    const path41 = resolveBinding(ctx, radiusId);
-    if (path41 !== void 0) tokens.add(path41);
+    const path44 = resolveBinding(ctx, radiusId);
+    if (path44 !== void 0) tokens.add(path44);
   } else if (typeof raw["cornerRadius"] === "number" && raw["cornerRadius"] !== 0) {
     ctx.hardcoded.push({ node: name, property: "border-radius", value: `${raw["cornerRadius"]}px` });
   }
@@ -1729,10 +2117,10 @@ function walk(ctx, raw) {
     layout = { mode: layoutMode === "HORIZONTAL" ? "flex-row" : "flex-column" };
     const gapId = boundId(raw["itemSpacing"]);
     if (gapId !== void 0) {
-      const path41 = resolveBinding(ctx, gapId);
-      if (path41 !== void 0) {
-        layout.gap = path41;
-        tokens.add(path41);
+      const path44 = resolveBinding(ctx, gapId);
+      if (path44 !== void 0) {
+        layout.gap = path44;
+        tokens.add(path44);
       }
     } else if (typeof raw["itemSpacing"] === "number" && raw["itemSpacing"] !== 0) {
       ctx.hardcoded.push({ node: name, property: "gap", value: `${raw["itemSpacing"]}px` });
@@ -1741,10 +2129,10 @@ function walk(ctx, raw) {
     for (const field of PADDING_FIELDS) {
       const id = boundId(raw[field]);
       if (id !== void 0) {
-        const path41 = resolveBinding(ctx, id);
-        if (path41 !== void 0) {
-          paddingPaths.push(path41);
-          tokens.add(path41);
+        const path44 = resolveBinding(ctx, id);
+        if (path44 !== void 0) {
+          paddingPaths.push(path44);
+          tokens.add(path44);
         }
       } else if (typeof raw[field] === "number" && raw[field] !== 0) {
         ctx.hardcoded.push({ node: name, property: field, value: `${raw[field]}px` });
@@ -1952,25 +2340,25 @@ var init_src3 = __esm({
 });
 
 // packages/cli/src/invocation.ts
-import { existsSync as existsSync3, realpathSync } from "node:fs";
-import path3 from "node:path";
+import { existsSync as existsSync4, realpathSync } from "node:fs";
+import path4 from "node:path";
 import { fileURLToPath } from "node:url";
 function findPathTendril(pathEnv, platform) {
-  const dirs = pathEnv.split(path3.delimiter).filter((d) => d !== "" && !/node_modules[\\/]\.bin/.test(d) && !/[\\/]_npx[\\/]/.test(d));
+  const dirs = pathEnv.split(path4.delimiter).filter((d) => d !== "" && !/node_modules[\\/]\.bin/.test(d) && !/[\\/]_npx[\\/]/.test(d));
   const names = platform === "win32" ? ["tendril.cmd", "tendril.bat"] : ["tendril"];
   for (const dir of dirs) {
     for (const name of names) {
-      const candidate = path3.join(dir, name);
-      if (existsSync3(candidate)) return candidate;
+      const candidate = path4.join(dir, name);
+      if (existsSync4(candidate)) return candidate;
     }
   }
   return null;
 }
 function packageRootOf(file) {
-  let dir = path3.dirname(file);
+  let dir = path4.dirname(file);
   for (; ; ) {
-    if (existsSync3(path3.join(dir, "package.json"))) return dir;
-    const parent = path3.dirname(dir);
+    if (existsSync4(path4.join(dir, "package.json"))) return dir;
+    const parent = path4.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -2009,18 +2397,18 @@ var init_invocation = __esm({
 
 // packages/verify/src/browser.ts
 import { execFileSync } from "node:child_process";
-import { existsSync as existsSync4, readdirSync } from "node:fs";
-import path4 from "node:path";
+import { existsSync as existsSync5, readdirSync as readdirSync2 } from "node:fs";
+import path5 from "node:path";
 function resolveChrome() {
   const fromEnv = process.env["TENDRIL_CHROME"] ?? process.env["CHROME_PATH"];
   if (fromEnv !== void 0 && fromEnv !== "") {
-    if (!existsSync4(fromEnv)) {
+    if (!existsSync5(fromEnv)) {
       throw new Error(`CHROME_PATH points at ${fromEnv}, which does not exist \u2014 fix the variable or unset it to use discovery`);
     }
     return fromEnv;
   }
   const candidates = process.platform === "darwin" ? MAC_CANDIDATES : process.platform === "win32" ? WIN_CANDIDATES : [];
-  for (const c of candidates) if (existsSync4(c)) return c;
+  for (const c of candidates) if (existsSync5(c)) return c;
   if (process.platform !== "win32") {
     for (const name of PATH_NAMES) {
       try {
@@ -2034,7 +2422,7 @@ function resolveChrome() {
 }
 function versionFromInstallDir(exePath) {
   try {
-    const builds = readdirSync(path4.dirname(exePath), { withFileTypes: true }).filter((e) => e.isDirectory() && /^\d+(\.\d+){3}$/.test(e.name)).map((e) => e.name.split(".").map(Number));
+    const builds = readdirSync2(path5.dirname(exePath), { withFileTypes: true }).filter((e) => e.isDirectory() && /^\d+(\.\d+){3}$/.test(e.name)).map((e) => e.name.split(".").map(Number));
     builds.sort((a, b) => a[0] - b[0] || a[1] - b[1] || a[2] - b[2] || a[3] - b[3]);
     return builds.length === 0 ? null : builds[builds.length - 1].join(".");
   } catch {
@@ -2046,7 +2434,7 @@ function windowsBrowserName(exePath) {
   if (p.includes("\\google\\chrome\\")) return "Google Chrome";
   if (p.includes("\\microsoft\\edge\\")) return "Microsoft Edge";
   if (p.includes("chromium")) return "Chromium";
-  return path4.win32.basename(exePath, ".exe");
+  return path5.win32.basename(exePath, ".exe");
 }
 function chromeVersion() {
   if (_version !== void 0) return _version;
@@ -2081,32 +2469,32 @@ var init_browser = __esm({
 });
 
 // packages/verify/src/runtime.ts
-import { existsSync as existsSync5, mkdtempSync, symlinkSync } from "node:fs";
+import { existsSync as existsSync6, mkdtempSync, symlinkSync } from "node:fs";
 import { createRequire } from "node:module";
 import os from "node:os";
-import path5 from "node:path";
+import path6 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function runtimePackageRoot() {
   const env = process.env["TENDRIL_PACKAGE_ROOT"];
-  if (env !== void 0 && env !== "") return path5.resolve(env);
-  return path5.resolve(path5.dirname(fileURLToPath2(import.meta.url)), "..");
+  if (env !== void 0 && env !== "") return path6.resolve(env);
+  return path6.resolve(path6.dirname(fileURLToPath2(import.meta.url)), "..");
 }
 function runtimeNodeModules() {
   const root = runtimePackageRoot();
-  for (let dir = root; ; dir = path5.dirname(dir)) {
-    const candidate = path5.basename(dir) === "node_modules" ? dir : path5.join(dir, "node_modules");
-    if (existsSync5(path5.join(candidate, "react"))) return candidate;
-    if (path5.dirname(dir) === dir) break;
+  for (let dir = root; ; dir = path6.dirname(dir)) {
+    const candidate = path6.basename(dir) === "node_modules" ? dir : path6.join(dir, "node_modules");
+    if (existsSync6(path6.join(candidate, "react"))) return candidate;
+    if (path6.dirname(dir) === dir) break;
   }
   throw new Error(
     `Tendril's installed dependencies are missing: no node_modules containing react found at or above ${root}. This is an INSTALLATION problem, not a component error \u2014 reinstall with \`npm install -g @tendrilapp/cli\` (or \`tendrilapp\`) and retry.`
   );
 }
 function newScratchDir(prefix) {
-  const dir = mkdtempSync(path5.join(os.tmpdir(), `tendril-${prefix}-`));
+  const dir = mkdtempSync(path6.join(os.tmpdir(), `tendril-${prefix}-`));
   const nodeModules = runtimeNodeModules();
   try {
-    symlinkSync(nodeModules, path5.join(dir, "node_modules"), "junction");
+    symlinkSync(nodeModules, path6.join(dir, "node_modules"), "junction");
   } catch (err) {
     throw new Error(
       `Tendril could not link its dependencies into the scratch dir (${nodeModules} -> ${dir}): ${err instanceof Error ? err.message : String(err)}. This is an environment problem, not a component error.`
@@ -2115,7 +2503,7 @@ function newScratchDir(prefix) {
   return dir;
 }
 function reactPinPlugin() {
-  const req = createRequire(path5.join(runtimePackageRoot(), "package.json"));
+  const req = createRequire(path6.join(runtimePackageRoot(), "package.json"));
   return {
     name: "tendril-react-pin",
     setup(b) {
@@ -2168,9 +2556,9 @@ var init_gates = __esm({
 
 // packages/verify/src/tsc-check.ts
 import ts from "typescript";
-import path6 from "node:path";
+import path7 from "node:path";
 function runTscStrict(files) {
-  const program = ts.createProgram(files.map((f) => path6.resolve(f)), STRICT_OPTIONS);
+  const program = ts.createProgram(files.map((f) => path7.resolve(f)), STRICT_OPTIONS);
   const diagnostics = ts.getPreEmitDiagnostics(program);
   const mapped = diagnostics.map((d) => {
     const file = d.file?.fileName;
@@ -2331,7 +2719,7 @@ var init_token_lint = __esm({
 
 // packages/verify/src/loop.ts
 import { rmSync, writeFileSync as writeFileSync2 } from "node:fs";
-import path7 from "node:path";
+import path8 from "node:path";
 async function runChecks(componentName, files, extraFiles, definedVars2) {
   const findings = [];
   for (const violation of scanForbiddenPatterns(files.tsx)) {
@@ -2346,10 +2734,10 @@ async function runChecks(componentName, files, extraFiles, definedVars2) {
   }
   const workDir = newScratchDir("loop");
   try {
-    const tsxPath = path7.join(workDir, `${componentName}.tsx`);
+    const tsxPath = path8.join(workDir, `${componentName}.tsx`);
     writeFileSync2(tsxPath, files.tsx);
     for (const [name, content] of Object.entries(extraFiles ?? {})) {
-      writeFileSync2(path7.join(workDir, name), content);
+      writeFileSync2(path8.join(workDir, name), content);
     }
     const tsc = runTscStrict([tsxPath]);
     for (const d of tsc.diagnostics) {
@@ -2414,7 +2802,7 @@ var init_loop = __esm({
 });
 
 // packages/verify/src/report.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 function isTokenEnforcedProperty(property) {
   return enforcedMatchers.some((m) => m.test(property));
 }
@@ -2456,58 +2844,58 @@ var init_report = __esm({
   "packages/verify/src/report.ts"() {
     "use strict";
     init_token_lint();
-    ReportSchema = z5.object({
-      component: z5.string(),
-      tokenAdherence: z5.number().min(0).max(100),
-      tokenViolations: z5.number(),
-      tscPass: z5.boolean(),
-      gatesClean: z5.boolean(),
+    ReportSchema = z6.object({
+      component: z6.string(),
+      tokenAdherence: z6.number().min(0).max(100),
+      tokenViolations: z6.number(),
+      tscPass: z6.boolean(),
+      gatesClean: z6.boolean(),
       /** null = check skipped in this phase (recorded in skippedChecks). */
-      axeViolations: z5.number().nullable(),
-      visualDiff: z5.object({
-        method: z5.string(),
-        score: z5.number().nullable(),
-        flags: z5.array(z5.string()),
+      axeViolations: z6.number().nullable(),
+      visualDiff: z6.object({
+        method: z6.string(),
+        score: z6.number().nullable(),
+        flags: z6.array(z6.string()),
         /** Reference-image oracle (ADR-004 pillar B). */
-        imageSimilarity: z5.object({
-          variants: z5.number(),
-          mean: z5.number(),
-          worst: z5.number(),
-          perVariant: z5.array(
-            z5.object({
-              label: z5.string(),
-              similarity: z5.number(),
-              ink: z5.number().optional(),
-              region: z5.string().optional()
+        imageSimilarity: z6.object({
+          variants: z6.number(),
+          mean: z6.number(),
+          worst: z6.number(),
+          perVariant: z6.array(
+            z6.object({
+              label: z6.string(),
+              similarity: z6.number(),
+              ink: z6.number().optional(),
+              region: z6.string().optional()
             })
           ).optional()
         }).optional(),
         /** What the score covers — the number carries its own caveats. */
-        coverage: z5.object({
-          factChecks: z5.number(),
-          imageVariants: z5.number(),
-          unmeasured: z5.array(z5.string())
+        coverage: z6.object({
+          factChecks: z6.number(),
+          imageVariants: z6.number(),
+          unmeasured: z6.array(z6.string())
         }).optional()
       }),
-      repairIterations: z5.number(),
-      skippedChecks: z5.array(z5.string()),
-      model: z5.object({ id: z5.string(), status: z5.enum(["verified", "degraded"]) }),
+      repairIterations: z6.number(),
+      skippedChecks: z6.array(z6.string()),
+      model: z6.object({ id: z6.string(), status: z6.enum(["verified", "degraded"]) }),
       /** Who authored the stylesheet — keeps eval numbers comparable if
        * authorship ever changes (ADR-005; review finding on ADR-004). */
-      styling: z5.enum(["model", "compiled"]).default("model"),
+      styling: z6.enum(["model", "compiled"]).default("model"),
       /** Per-run model usage: BYOK economics must be observable, not folklore.
        * Absent when the transport has no metering (mock runs). */
-      usage: z5.object({
-        calls: z5.number(),
-        promptTokens: z5.number(),
-        completionTokens: z5.number(),
+      usage: z6.object({
+        calls: z6.number(),
+        promptTokens: z6.number(),
+        completionTokens: z6.number(),
         /** OpenRouter-reported USD (0 when the provider didn't report). */
-        cost: z5.number()
+        cost: z6.number()
       }).optional(),
-      transport: z5.string(),
-      toolVersion: z5.string(),
-      generatedAt: z5.string(),
-      needsHumanReview: z5.array(z5.string())
+      transport: z6.string(),
+      toolVersion: z6.string(),
+      generatedAt: z6.string(),
+      needsHumanReview: z6.array(z6.string())
     });
     enforcedMatchers = TOKEN_ENFORCED_PROPERTIES.map(
       (entry) => entry.startsWith("/") && entry.endsWith("/") ? new RegExp(entry.slice(1, -1)) : new RegExp(`^${entry}$`)
@@ -2991,7 +3379,7 @@ var init_image_diff = __esm({
 });
 
 // packages/verify/src/visual-facts.ts
-import path8 from "node:path";
+import path9 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { build } from "esbuild";
 import { chromium } from "playwright-core";
@@ -3536,7 +3924,7 @@ var init_visual_facts = __esm({
     init_browser();
     init_mount_limits();
     init_image_diff();
-    RESOLVE_DIR = path8.resolve(path8.dirname(fileURLToPath3(import.meta.url)), "..");
+    RESOLVE_DIR = path9.resolve(path9.dirname(fileURLToPath3(import.meta.url)), "..");
     TOLERANCE_PX = 2;
     WIDTH_SLACK = 0.25;
     IMAGE_SIMILARITY_FLOOR = 0.8;
@@ -3545,14 +3933,14 @@ var init_visual_facts = __esm({
 });
 
 // packages/verify/src/paths.ts
-import path9 from "node:path";
+import path10 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var VERIFY_PKG_DIR, REPO_ROOT;
 var init_paths = __esm({
   "packages/verify/src/paths.ts"() {
     "use strict";
-    VERIFY_PKG_DIR = path9.resolve(path9.dirname(fileURLToPath4(import.meta.url)), "..");
-    REPO_ROOT = path9.resolve(VERIFY_PKG_DIR, "..", "..");
+    VERIFY_PKG_DIR = path10.resolve(path10.dirname(fileURLToPath4(import.meta.url)), "..");
+    REPO_ROOT = path10.resolve(VERIFY_PKG_DIR, "..", "..");
   }
 });
 
@@ -3671,9 +4059,9 @@ var init_font_collection = __esm({
 });
 
 // packages/verify/src/font-discovery.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync3, realpathSync as realpathSync2 } from "node:fs";
+import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync4, realpathSync as realpathSync2 } from "node:fs";
 import os2 from "node:os";
-import path10 from "node:path";
+import path11 from "node:path";
 function weightFromSubfamily(subfamily) {
   for (const [re, w] of WEIGHT_TOKENS) if (re.test(subfamily)) return w;
   return void 0;
@@ -3719,7 +4107,7 @@ function faceAt(bytes, view, dirOffset, file, faceIndex) {
 }
 function facesInFile(file) {
   try {
-    const bytes = new Uint8Array(readFileSync3(file));
+    const bytes = new Uint8Array(readFileSync4(file));
     if (bytes.length < 12) return [];
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
     if (isCollection(bytes)) {
@@ -3739,13 +4127,13 @@ function facesInFile(file) {
 }
 function systemFontDirs() {
   const env = process.env["TENDRIL_SYSTEM_FONT_DIRS"];
-  if (env !== void 0 && env !== "") return env.split(path10.delimiter).filter((d) => d !== "" && existsSync6(d));
+  if (env !== void 0 && env !== "") return env.split(path11.delimiter).filter((d) => d !== "" && existsSync7(d));
   const home = os2.homedir();
-  const dirs = process.platform === "darwin" ? ["/System/Library/Fonts", "/Library/Fonts", path10.join(home, "Library", "Fonts")] : process.platform === "win32" ? [
-    path10.join(process.env["WINDIR"] ?? "C:\\Windows", "Fonts"),
-    ...process.env["LOCALAPPDATA"] !== void 0 ? [path10.join(process.env["LOCALAPPDATA"], "Microsoft", "Windows", "Fonts")] : []
-  ] : ["/usr/share/fonts", "/usr/local/share/fonts", path10.join(home, ".fonts"), path10.join(home, ".local", "share", "fonts")];
-  return dirs.filter((d) => existsSync6(d));
+  const dirs = process.platform === "darwin" ? ["/System/Library/Fonts", "/Library/Fonts", path11.join(home, "Library", "Fonts")] : process.platform === "win32" ? [
+    path11.join(process.env["WINDIR"] ?? "C:\\Windows", "Fonts"),
+    ...process.env["LOCALAPPDATA"] !== void 0 ? [path11.join(process.env["LOCALAPPDATA"], "Microsoft", "Windows", "Fonts")] : []
+  ] : ["/usr/share/fonts", "/usr/local/share/fonts", path11.join(home, ".fonts"), path11.join(home, ".local", "share", "fonts")];
+  return dirs.filter((d) => existsSync7(d));
 }
 function discoverSystemFaces(dirs = systemFontDirs(), depth = 3) {
   const seen = /* @__PURE__ */ new Set();
@@ -3754,15 +4142,15 @@ function discoverSystemFaces(dirs = systemFontDirs(), depth = 3) {
     for (const dir of dirList) {
       let entries;
       try {
-        entries = readdirSync2(dir, { withFileTypes: true });
+        entries = readdirSync3(dir, { withFileTypes: true });
       } catch {
         continue;
       }
       for (const e of entries) {
-        const full = path10.join(dir, e.name);
+        const full = path11.join(dir, e.name);
         if (e.isDirectory()) {
           if (remaining > 1) faces.push(...walk2([full], remaining - 1));
-        } else if (FONT_EXTENSIONS.has(path10.extname(e.name).toLowerCase())) {
+        } else if (FONT_EXTENSIONS.has(path11.extname(e.name).toLowerCase())) {
           let key = full;
           try {
             key = realpathSync2(full);
@@ -3810,14 +4198,14 @@ var init_font_discovery = __esm({
 });
 
 // packages/verify/src/font-resolve.ts
-import { createHash } from "node:crypto";
-import { existsSync as existsSync7, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "node:fs";
 import os3 from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 function fontCacheDir() {
   const env = process.env["TENDRIL_FONT_CACHE"];
-  if (env !== void 0 && env !== "") return path11.resolve(env);
-  return path11.join(os3.homedir(), ".tendril", "fonts");
+  if (env !== void 0 && env !== "") return path12.resolve(env);
+  return path12.join(os3.homedir(), ".tendril", "fonts");
 }
 function normalizeFontLicense(value) {
   return typeof value === "string" && FONT_LICENSES.includes(value) ? value : "unknown";
@@ -3881,30 +4269,30 @@ async function resolveFonts(family, weights, cacheDir = DEFAULT_FONT_CACHE) {
         continue;
       }
       const bytes = new Uint8Array(await fileRes.arrayBuffer());
-      const sha256 = createHash("sha256").update(bytes).digest("hex");
-      const file = path11.join(cacheDir, `${family.toLowerCase().replace(/\s+/g, "-")}-${weight}.woff2`);
+      const sha256 = createHash2("sha256").update(bytes).digest("hex");
+      const file = path12.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 } : {} });
     } catch (err) {
       failures.push({ family, weight, reason: `download failed: ${err instanceof Error ? err.message : String(err)}` });
     }
   }
-  const mPath = path11.join(cacheDir, "manifest.json");
-  const prior = existsSync7(mPath) ? JSON.parse(readFileSync4(mPath, "utf8")) : [];
-  const portable2 = resolved.map((m) => ({ ...m, file: path11.basename(m.file) }));
+  const mPath = path12.join(cacheDir, "manifest.json");
+  const prior = existsSync8(mPath) ? JSON.parse(readFileSync5(mPath, "utf8")) : [];
+  const portable2 = resolved.map((m) => ({ ...m, file: path12.basename(m.file) }));
   const merged = [...prior.filter((p) => !resolved.some((m) => m.family === p.family && m.weight === p.weight)), ...portable2];
   if (resolved.length > 0) writeFileSync3(mPath, `${JSON.stringify(merged, null, 2)}
 `);
   return { resolved, failures };
 }
 function addLocalFont(family, weight, filePath, cacheDir = DEFAULT_FONT_CACHE, faceIndex, provenance = "local") {
-  const src = path11.resolve(filePath);
-  if (!existsSync7(src)) throw new Error(`font file not found: ${src}`);
-  const ext = path11.extname(src).toLowerCase();
+  const src = path12.resolve(filePath);
+  if (!existsSync8(src)) throw new Error(`font file not found: ${src}`);
+  const ext = path12.extname(src).toLowerCase();
   if (![".woff2", ".woff", ".ttf", ".otf", ".ttc"].includes(ext)) {
     throw new Error(`unsupported font file "${ext}" \u2014 use .woff2 (preferred), .woff, .ttf, .otf or .ttc`);
   }
-  let bytes = new Uint8Array(readFileSync4(src));
+  let bytes = new Uint8Array(readFileSync5(src));
   if (bytes.length === 0) throw new Error(`font file is empty: ${src}`);
   let storedExt = ext;
   if (isCollection(bytes)) {
@@ -3914,7 +4302,7 @@ function addLocalFont(family, weight, filePath, cacheDir = DEFAULT_FONT_CACHE, f
       const all = listCollectionFaces(bytes);
       const shown = (candidates.length > 0 ? candidates : all).map((f) => `  --face ${f.index}  ${f.family ?? "(unnamed)"}${f.subfamily !== void 0 ? ` ${f.subfamily}` : ""}`).join("\n");
       throw new Error(
-        `${path11.basename(src)} is a collection of ${all.length} faces and ${candidates.length === 0 ? `none is named "${family}"` : `${candidates.length} match "${family}"`} \u2014 name the one you mean with --face <index>:
+        `${path12.basename(src)} is a collection of ${all.length} faces and ${candidates.length === 0 ? `none is named "${family}"` : `${candidates.length} match "${family}"`} \u2014 name the one you mean with --face <index>:
 ${shown}`
       );
     }
@@ -3922,21 +4310,21 @@ ${shown}`
     storedExt = ".ttf";
   }
   mkdirSync2(cacheDir, { recursive: true });
-  const sha256 = createHash("sha256").update(bytes).digest("hex");
-  const file = path11.join(cacheDir, `${family.toLowerCase().replace(/\s+/g, "-")}-${weight}${storedExt}`);
+  const sha256 = createHash2("sha256").update(bytes).digest("hex");
+  const file = path12.join(cacheDir, `${family.toLowerCase().replace(/\s+/g, "-")}-${weight}${storedExt}`);
   writeFileSync3(file, bytes);
-  const face = { family, weight, source: `${provenance}:${path11.basename(src)}`, sha256, file, license: "unknown" };
-  const mPath = path11.join(cacheDir, "manifest.json");
-  const prior = existsSync7(mPath) ? JSON.parse(readFileSync4(mPath, "utf8")) : [];
-  const merged = [...prior.filter((p) => !(p.family === family && p.weight === weight)), { ...face, file: path11.basename(file) }];
+  const face = { family, weight, source: `${provenance}:${path12.basename(src)}`, sha256, file, license: "unknown" };
+  const mPath = path12.join(cacheDir, "manifest.json");
+  const prior = existsSync8(mPath) ? JSON.parse(readFileSync5(mPath, "utf8")) : [];
+  const merged = [...prior.filter((p) => !(p.family === family && p.weight === weight)), { ...face, file: path12.basename(file) }];
   writeFileSync3(mPath, `${JSON.stringify(merged, null, 2)}
 `);
   return face;
 }
 function checkFontLock(lockPath, cacheDir = DEFAULT_FONT_CACHE) {
-  const lock = JSON.parse(readFileSync4(lockPath, "utf8"));
-  const mPath = path11.join(cacheDir, "manifest.json");
-  const manifest = existsSync7(mPath) ? JSON.parse(readFileSync4(mPath, "utf8")) : [];
+  const lock = JSON.parse(readFileSync5(lockPath, "utf8"));
+  const mPath = path12.join(cacheDir, "manifest.json");
+  const manifest = existsSync8(mPath) ? JSON.parse(readFileSync5(mPath, "utf8")) : [];
   return lock.map((l) => {
     const m = manifest.find((x) => x.family === l.family && x.weight === l.weight);
     if (m === void 0) return { family: l.family, weight: l.weight, status: "missing" };
@@ -3944,11 +4332,11 @@ function checkFontLock(lockPath, cacheDir = DEFAULT_FONT_CACHE) {
   });
 }
 function resolvedFontFamilies(cacheDir = DEFAULT_FONT_CACHE) {
-  const mPath = path11.join(cacheDir, "manifest.json");
-  if (!existsSync7(mPath)) return [];
+  const mPath = path12.join(cacheDir, "manifest.json");
+  if (!existsSync8(mPath)) return [];
   let entries;
   try {
-    entries = JSON.parse(readFileSync4(mPath, "utf8"));
+    entries = JSON.parse(readFileSync5(mPath, "utf8"));
   } catch {
     return [];
   }
@@ -3962,8 +4350,8 @@ function resolvedFontFamilies(cacheDir = DEFAULT_FONT_CACHE) {
   return [...byFamily.entries()].map(([family, w]) => ({ family, weights: [...w].sort((a, b) => a - b) }));
 }
 function requiredFontsManifest(families, cacheDir = DEFAULT_FONT_CACHE) {
-  const mPath = path11.join(cacheDir, "manifest.json");
-  const manifest = existsSync7(mPath) ? JSON.parse(readFileSync4(mPath, "utf8")) : [];
+  const mPath = path12.join(cacheDir, "manifest.json");
+  const manifest = existsSync8(mPath) ? JSON.parse(readFileSync5(mPath, "utf8")) : [];
   const wanted = new Set(families.map((f) => f.toLowerCase()));
   return manifest.filter((f) => wanted.has(f.family.toLowerCase())).map((f) => ({
     family: f.family,
@@ -3976,11 +4364,11 @@ function requiredFontsManifest(families, cacheDir = DEFAULT_FONT_CACHE) {
   }));
 }
 function facesMissingLicense(cacheDir = DEFAULT_FONT_CACHE) {
-  const mPath = path11.join(cacheDir, "manifest.json");
-  if (!existsSync7(mPath)) return [];
+  const mPath = path12.join(cacheDir, "manifest.json");
+  if (!existsSync8(mPath)) return [];
   let entries;
   try {
-    entries = JSON.parse(readFileSync4(mPath, "utf8"));
+    entries = JSON.parse(readFileSync5(mPath, "utf8"));
   } catch {
     return [];
   }
@@ -3989,20 +4377,20 @@ function facesMissingLicense(cacheDir = DEFAULT_FONT_CACHE) {
   ).map((e) => ({ family: e.family, weight: e.weight, sha256: e.sha256 }));
 }
 function verifiedFontFamilies(cacheDir = DEFAULT_FONT_CACHE) {
-  const mPath = path11.join(cacheDir, "manifest.json");
-  if (!existsSync7(mPath)) return [];
+  const mPath = path12.join(cacheDir, "manifest.json");
+  if (!existsSync8(mPath)) return [];
   let entries;
   try {
-    entries = JSON.parse(readFileSync4(mPath, "utf8"));
+    entries = JSON.parse(readFileSync5(mPath, "utf8"));
   } catch {
     return [];
   }
   const byFamily = /* @__PURE__ */ new Map();
   for (const e of entries) {
     if (typeof e.family !== "string" || typeof e.weight !== "number" || typeof e.file !== "string") continue;
-    const file = path11.isAbsolute(e.file) && existsSync7(e.file) ? e.file : path11.resolve(cacheDir, path11.basename(e.file));
-    if (!existsSync7(file)) continue;
-    if (createHash("sha256").update(readFileSync4(file)).digest("hex") !== e.sha256) continue;
+    const file = path12.isAbsolute(e.file) && existsSync8(e.file) ? e.file : path12.resolve(cacheDir, path12.basename(e.file));
+    if (!existsSync8(file)) continue;
+    if (createHash2("sha256").update(readFileSync5(file)).digest("hex") !== e.sha256) continue;
     const set = byFamily.get(e.family) ?? /* @__PURE__ */ new Set();
     set.add(e.weight);
     byFamily.set(e.family, set);
@@ -4023,8 +4411,8 @@ function addSystemFamily(family, opts = {}) {
   const skipped = [];
   const overwrote = [];
   const cacheDir = opts.cacheDir ?? DEFAULT_FONT_CACHE;
-  const manifestFile = path11.join(cacheDir, "manifest.json");
-  const prior = existsSync7(manifestFile) ? JSON.parse(readFileSync4(manifestFile, "utf8")) : [];
+  const manifestFile = path12.join(cacheDir, "manifest.json");
+  const prior = existsSync8(manifestFile) ? JSON.parse(readFileSync5(manifestFile, "utf8")) : [];
   const taken = /* @__PURE__ */ new Set();
   for (const face of faces) {
     const skip = (reason) => skipped.push({ subfamily: face.subfamily, weight: face.weight, reason });
@@ -4085,18 +4473,18 @@ var init_font_resolve = __esm({
 });
 
 // packages/verify/src/font-faces.ts
-import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync8, readFileSync as readFileSync5 } from "node:fs";
-import path12 from "node:path";
+import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync9, readFileSync as readFileSync6 } from "node:fs";
+import path13 from "node:path";
 function injectedGroups(manifestPath2) {
-  if (!existsSync8(manifestPath2)) return { groups: [], shared: false };
-  const claimed = JSON.parse(readFileSync5(manifestPath2, "utf8"));
-  const resolveFile = (f) => path12.isAbsolute(f) && existsSync8(f) ? f : path12.resolve(path12.dirname(manifestPath2), path12.basename(f));
+  if (!existsSync9(manifestPath2)) return { groups: [], shared: false };
+  const claimed = JSON.parse(readFileSync6(manifestPath2, "utf8"));
+  const resolveFile = (f) => path13.isAbsolute(f) && existsSync9(f) ? f : path13.resolve(path13.dirname(manifestPath2), path13.basename(f));
   const byFile = /* @__PURE__ */ new Map();
   for (const f of claimed) {
     const file = resolveFile(f.file);
-    if (!existsSync8(file)) continue;
-    if (createHash2("sha256").update(readFileSync5(file)).digest("hex") !== f.sha256) continue;
+    if (!existsSync9(file)) continue;
+    if (createHash3("sha256").update(readFileSync6(file)).digest("hex") !== f.sha256) continue;
     const k = `${f.family}:${f.file}`;
     const e = byFile.get(k) ?? { family: f.family, weights: [], file };
     e.weights.push(f.weight);
@@ -4105,14 +4493,14 @@ function injectedGroups(manifestPath2) {
   const groups = [...byFile.values()];
   return { groups, shared: new Set(groups.map((e) => e.file)).size < groups.length };
 }
-function fontFaceCss(manifestPath2 = path12.join(fontCacheDir(), "manifest.json")) {
+function fontFaceCss(manifestPath2 = path13.join(fontCacheDir(), "manifest.json")) {
   const { groups, shared } = injectedGroups(manifestPath2);
   return groups.map((e) => {
     const weight = shared || e.weights.length > 1 ? `${SPAN[0]} ${SPAN[1]}` : String(e.weights[0]);
-    return `@font-face { font-family: '${e.family}'; font-weight: ${weight}; font-style: normal; src: url(data:font/woff2;base64,${readFileSync5(e.file).toString("base64")}) format('woff2'); }`;
+    return `@font-face { font-family: '${e.family}'; font-weight: ${weight}; font-style: normal; src: url(data:font/woff2;base64,${readFileSync6(e.file).toString("base64")}) format('woff2'); }`;
   }).join("\n");
 }
-function injectedFamilyWeights(manifestPath2 = path12.join(fontCacheDir(), "manifest.json")) {
+function injectedFamilyWeights(manifestPath2 = path13.join(fontCacheDir(), "manifest.json")) {
   const { groups, shared } = injectedGroups(manifestPath2);
   const out = /* @__PURE__ */ new Map();
   for (const g of groups) {
@@ -4137,17 +4525,17 @@ var init_font_faces = __esm({
 });
 
 // packages/verify/src/admission.ts
-import { readFileSync as readFileSync6, readdirSync as readdirSync3, existsSync as existsSync9, writeFileSync as writeFileSync4 } from "node:fs";
-import path13 from "node:path";
+import { readFileSync as readFileSync7, readdirSync as readdirSync4, existsSync as existsSync10, writeFileSync as writeFileSync4 } from "node:fs";
+import path14 from "node:path";
 import { build as build2 } from "esbuild";
 import postcss from "postcss";
 import tailwindcss from "tailwindcss";
 import { chromium as chromium2 } from "playwright-core";
 function fontWeightsByFamily() {
-  const mPath = path13.join(fontCacheDir(), "manifest.json");
+  const mPath = path14.join(fontCacheDir(), "manifest.json");
   const out = /* @__PURE__ */ new Map();
-  if (!existsSync9(mPath)) return out;
-  for (const f of JSON.parse(readFileSync6(mPath, "utf8")))
+  if (!existsSync10(mPath)) return out;
+  for (const f of JSON.parse(readFileSync7(mPath, "utf8")))
     out.set(f.family, [...out.get(f.family) ?? [], f.weight]);
   return out;
 }
@@ -4166,8 +4554,36 @@ var init_admission = __esm({
   }
 });
 
+// packages/verify/src/candidate-css.ts
+import { existsSync as existsSync11, readFileSync as readFileSync8, readdirSync as readdirSync5, statSync as statSync2 } from "node:fs";
+import path15 from "node:path";
+function candidateCss(bundleDir) {
+  const files = ["tokens.css", "styles.css"].map((f) => path15.join(bundleDir, f));
+  const composedRoot = path15.join(bundleDir, "composed");
+  let composedDirs = [];
+  try {
+    composedDirs = readdirSync5(composedRoot).sort();
+  } catch {
+  }
+  for (const entry of composedDirs) {
+    const dir = path15.join(composedRoot, entry);
+    try {
+      if (!statSync2(dir).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    files.push(path15.join(dir, "tokens.css"), path15.join(dir, "styles.css"));
+  }
+  return files.filter((f) => existsSync11(f)).map((f) => readFileSync8(f, "utf8")).join("\n");
+}
+var init_candidate_css = __esm({
+  "packages/verify/src/candidate-css.ts"() {
+    "use strict";
+  }
+});
+
 // packages/verify/src/tasks.ts
-import path14 from "node:path";
+import path16 from "node:path";
 var CALENDAR_CONFIGS, CALENDAR_API, CALENDAR_BEHAVIORS, BUTTON_CONFIGS, BUTTON_API, COMBO_FIX, COMBO_CONFIGS, COMBO_API, MODAL_CONFIGS, MODAL_API, BUTTON_BEHAVIORS, COMBO_BEHAVIORS, MODAL_BEHAVIORS, TASKS;
 var init_tasks = __esm({
   "packages/verify/src/tasks.ts"() {
@@ -4327,7 +4743,7 @@ BEHAVIORAL CONTRACT (machine-verified, gating): the primary action and close con
     ];
     TASKS = {
       calendar: {
-        set: path14.join(REPO_ROOT, "examples/recordings/shadcn-poc-calendar"),
+        set: path16.join(REPO_ROOT, "examples/recordings/shadcn-poc-calendar"),
         entry: "Calendar.tsx",
         configs: CALENDAR_CONFIGS,
         systemApi: CALENDAR_API,
@@ -4335,7 +4751,7 @@ BEHAVIORAL CONTRACT (machine-verified, gating): the primary action and close con
         prelude: { controls: ['[data-tendril-part="day"]'], textInputs: [] }
       },
       "shadcn-button": {
-        set: path14.join(REPO_ROOT, "examples/recordings/shadcn-poc-button"),
+        set: path16.join(REPO_ROOT, "examples/recordings/shadcn-poc-button"),
         entry: "Button.tsx",
         configs: BUTTON_CONFIGS,
         systemApi: BUTTON_API,
@@ -4343,7 +4759,7 @@ BEHAVIORAL CONTRACT (machine-verified, gating): the primary action and close con
         prelude: { controls: ["> *"], textInputs: [] }
       },
       combobox: {
-        set: path14.join(REPO_ROOT, "examples/recordings/carbon-poc-combobox"),
+        set: path16.join(REPO_ROOT, "examples/recordings/carbon-poc-combobox"),
         entry: "ComboBox.tsx",
         configs: COMBO_CONFIGS,
         systemApi: COMBO_API,
@@ -4351,7 +4767,7 @@ BEHAVIORAL CONTRACT (machine-verified, gating): the primary action and close con
         prelude: { controls: ['[role="option"]'], textInputs: ["input"], popover: { selector: '[role="listbox"]', trigger: "input" } }
       },
       modal: {
-        set: path14.join(REPO_ROOT, "examples/recordings/carbon-poc-modal"),
+        set: path16.join(REPO_ROOT, "examples/recordings/carbon-poc-modal"),
         entry: "Modal.tsx",
         configs: MODAL_CONFIGS,
         systemApi: MODAL_API,
@@ -4369,8 +4785,8 @@ __export(behavior_exports, {
   compileMount: () => compileMount,
   recordingIsDark: () => recordingIsDark
 });
-import { existsSync as existsSync10, readFileSync as readFileSync7 } from "node:fs";
-import path15 from "node:path";
+import { existsSync as existsSync12, readFileSync as readFileSync9 } from "node:fs";
+import path17 from "node:path";
 import { build as build3 } from "esbuild";
 import { chromium as chromium3 } from "playwright-core";
 import { PNG as PNG2 } from "pngjs";
@@ -4379,12 +4795,12 @@ function getFontFaces() {
   return _fontFaces;
 }
 async function compileMount(task, bundleDir) {
-  const entryTsx = path15.join(bundleDir, task.entry);
-  if (!existsSync10(entryTsx)) return { error: `${task.entry} missing` };
+  const entryTsx = path17.join(bundleDir, task.entry);
+  if (!existsSync12(entryTsx)) return { error: `${task.entry} missing` };
   const mountSrc = `
 import { createElement } from "react";
 import { createRoot } from "react-dom/client";
-import * as B from ${JSON.stringify(path15.resolve(entryTsx))};
+import * as B from ${JSON.stringify(path17.resolve(entryTsx))};
 const cfg = (window as unknown as { __cfg: { component: string; props: Record<string, unknown>; spyProps?: string[] } }).__cfg;
 const C = (B as Record<string, unknown>)[cfg.component] as Parameters<typeof createElement>[0] | undefined;
 // Callbacks cannot ride the JSON config: specs NAME spy props and the
@@ -4665,10 +5081,10 @@ async function runSteps(page, spec, renderPose) {
 function recordingIsDark(task) {
   const rep = task.configs[0]?.rep;
   if (rep === void 0) return false;
-  const f = path15.join(task.set, rep, "get_screenshot.json");
-  if (!existsSync10(f)) return false;
+  const f = path17.join(task.set, rep, "get_screenshot.json");
+  if (!existsSync12(f)) return false;
   try {
-    const env = JSON.parse(readFileSync7(f, "utf8")).content.find((c) => c.type === "image");
+    const env = JSON.parse(readFileSync9(f, "utf8")).content.find((c) => c.type === "image");
     if (env?.data === void 0) return false;
     const png = PNG2.sync.read(Buffer.from(env.data, "base64"));
     let sum = 0;
@@ -4740,7 +5156,7 @@ async function checkBehaviors(task, bundleDir, opts = {}) {
   const deadlineMs = timeoutMs + 1e4;
   const js = await compileMount(task, bundleDir);
   if (typeof js !== "string") return task.behaviors.map((b) => ({ id: b.id, pass: false, detail: js.error }));
-  const css = ["tokens.css", "styles.css"].map((f) => path15.join(bundleDir, f)).filter((f) => existsSync10(f)).map((f) => readFileSync7(f, "utf8")).join("\n");
+  const css = candidateCss(bundleDir);
   const server = await chromium3.launchServer({ executablePath: resolveChrome(), headless: true, args: mountArgs() });
   const browser = await chromium3.connect(server.wsEndpoint());
   const results = [];
@@ -4851,6 +5267,7 @@ var init_behavior = __esm({
     "use strict";
     init_runtime();
     init_browser();
+    init_candidate_css();
     init_font_faces();
     init_image_diff();
     init_mount_limits();
@@ -4883,8 +5300,8 @@ var init_behavior = __esm({
 });
 
 // packages/verify/src/bundle-quality.ts
-import { readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync5, existsSync as existsSync11 } from "node:fs";
-import path16 from "node:path";
+import { readFileSync as readFileSync10, rmSync as rmSync2, writeFileSync as writeFileSync5, existsSync as existsSync13 } from "node:fs";
+import path18 from "node:path";
 function definedVars(tokensCss) {
   if (tokensCss === void 0) return void 0;
   const names = /* @__PURE__ */ new Set();
@@ -4893,19 +5310,19 @@ function definedVars(tokensCss) {
 }
 function recordedTokenMapState(setDir, reps) {
   const readMap = (file) => {
-    if (!existsSync11(file)) return void 0;
+    if (!existsSync13(file)) return void 0;
     try {
-      const parsed = JSON.parse(envelopeFirstTextPart(JSON.parse(readFileSync8(file, "utf8"))) || "{}");
+      const parsed = JSON.parse(envelopeFirstTextPart(JSON.parse(readFileSync10(file, "utf8"))) || "{}");
       return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
     } catch {
       return {};
     }
   };
-  const setLevel = readMap(path16.join(setDir, "get_variable_defs.json"));
+  const setLevel = readMap(path18.join(setDir, "get_variable_defs.json"));
   if (setLevel !== void 0) return Object.keys(setLevel).length === 0 ? "empty" : "populated";
   let recorded = false;
   for (const rep of reps) {
-    const m = readMap(path16.join(setDir, rep, "get_variable_defs.json"));
+    const m = readMap(path18.join(setDir, rep, "get_variable_defs.json"));
     if (m === void 0) continue;
     recorded = true;
     if (Object.keys(m).length > 0) return "populated";
@@ -4970,11 +5387,11 @@ function fontStackFindings(sheets, coverage) {
 }
 async function checkBundleQuality(bundleDir, entry, set, fontManifest) {
   const findings = [];
-  const entryPath = path16.join(bundleDir, entry);
-  const cssPath = path16.join(bundleDir, "styles.css");
-  const tokensPath = path16.join(bundleDir, "tokens.css");
-  const css = existsSync11(cssPath) ? readFileSync8(cssPath, "utf8") : "";
-  const tokensCss = existsSync11(tokensPath) ? readFileSync8(tokensPath, "utf8") : void 0;
+  const entryPath = path18.join(bundleDir, entry);
+  const cssPath = path18.join(bundleDir, "styles.css");
+  const tokensPath = path18.join(bundleDir, "tokens.css");
+  const css = existsSync13(cssPath) ? readFileSync10(cssPath, "utf8") : "";
+  const tokensCss = existsSync13(tokensPath) ? readFileSync10(tokensPath, "utf8") : void 0;
   findings.push(
     ...fontStackFindings(
       [
@@ -4984,11 +5401,11 @@ async function checkBundleQuality(bundleDir, entry, set, fontManifest) {
       injectedFamilyWeights(fontManifest)
     )
   );
-  if (existsSync11(entryPath)) {
+  if (existsSync13(entryPath)) {
     const workDir = newScratchDir("quality");
     try {
-      const tsxPath = path16.join(workDir, entry);
-      writeFileSync5(tsxPath, readFileSync8(entryPath, "utf8"));
+      const tsxPath = path18.join(workDir, entry);
+      writeFileSync5(tsxPath, readFileSync10(entryPath, "utf8"));
       for (const d of runTscStrict([tsxPath]).diagnostics) {
         findings.push({ kind: "tsc", file: entry, ...d.line === void 0 ? {} : { line: d.line }, message: `TS${d.code}: ${d.message}` });
       }
@@ -5063,8 +5480,8 @@ var init_effect_geometry = __esm({
 });
 
 // packages/verify/src/bundle-score.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync3, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
-import path17 from "node:path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync3, readFileSync as readFileSync11, writeFileSync as writeFileSync6 } from "node:fs";
+import path19 from "node:path";
 import { build as build4 } from "esbuild";
 import { chromium as chromium4 } from "playwright-core";
 function getFontFaces2() {
@@ -5118,7 +5535,7 @@ function chooseSeat(cropAt, ref, padW, padH, backdrop, origin, extents) {
 }
 function metadataRoot(set, rep) {
   try {
-    const text = JSON.parse(readFileSync9(path17.join(set, rep, "get_metadata.json"), "utf8")).content.map((c) => c.text ?? "").join("\n");
+    const text = JSON.parse(readFileSync11(path19.join(set, rep, "get_metadata.json"), "utf8")).content.map((c) => c.text ?? "").join("\n");
     return parseMetadataStructure(text);
   } catch {
     return void 0;
@@ -5173,19 +5590,19 @@ function smallSemanticNodes(set, rep, maxArea = 1024) {
   });
 }
 function repMeta(set, rep) {
-  const text = JSON.parse(readFileSync9(path17.join(set, rep, "get_metadata.json"), "utf8")).content.map((c) => c.text ?? "").join("\n");
+  const text = JSON.parse(readFileSync11(path19.join(set, rep, "get_metadata.json"), "utf8")).content.map((c) => c.text ?? "").join("\n");
   const root = parseMetadataStructure(text);
   return { w: Math.round(root.width ?? 100), h: Math.round(root.height ?? 40) };
 }
 function repRef(set, rep) {
-  const env = JSON.parse(readFileSync9(path17.join(set, rep, "get_screenshot.json"), "utf8")).content.find((c) => c.type === "image");
+  const env = JSON.parse(readFileSync11(path19.join(set, rep, "get_screenshot.json"), "utf8")).content.find((c) => c.type === "image");
   return Uint8Array.from(Buffer.from(env?.data ?? "", "base64"));
 }
 function repEffectExtents(set, rep) {
-  const file = path17.join(set, rep, "get_design_context.json");
-  if (!existsSync12(file)) return void 0;
+  const file = path19.join(set, rep, "get_design_context.json");
+  if (!existsSync14(file)) return void 0;
   try {
-    const text = JSON.parse(readFileSync9(file, "utf8")).content.map((c) => c.text ?? "").join("\n");
+    const text = JSON.parse(readFileSync11(file, "utf8")).content.map((c) => c.text ?? "").join("\n");
     const extents = shadowExtents(text);
     return extents.top + extents.right + extents.bottom + extents.left > 0 ? extents : void 0;
   } catch {
@@ -5196,13 +5613,13 @@ async function scoreBundleForTask(task, bundleDir, bar = BAR, opts = {}) {
   if (opts.evidenceDir !== void 0) mkdirSync3(opts.evidenceDir, { recursive: true });
   const CONFIGS2 = task.configs;
   const timeoutMs = opts.mountDeadlineMs ?? ENGINE_MOUNT_DEADLINE_MS;
-  const entryTsx = path17.join(bundleDir, task.entry);
-  if (!existsSync12(entryTsx)) return CONFIGS2.map((c) => ({ rep: c.rep, similarity: 0, inkRecall: 0, exact: { similarity: 0, inkRecall: 0 }, pass: false, error: `${task.entry} missing` }));
-  const css = ["tokens.css", "styles.css"].map((f) => path17.join(bundleDir, f)).filter((f) => existsSync12(f)).map((f) => readFileSync9(f, "utf8")).join("\n");
+  const entryTsx = path19.join(bundleDir, task.entry);
+  if (!existsSync14(entryTsx)) return CONFIGS2.map((c) => ({ rep: c.rep, similarity: 0, inkRecall: 0, exact: { similarity: 0, inkRecall: 0 }, pass: false, error: `${task.entry} missing` }));
+  const css = candidateCss(bundleDir);
   const mountSrc = `
 import { createElement } from "react";
 import { createRoot } from "react-dom/client";
-import * as B from ${JSON.stringify(path17.resolve(entryTsx))};
+import * as B from ${JSON.stringify(path19.resolve(entryTsx))};
 const cfg = (window as unknown as { __cfg: { component: string; props: Record<string, unknown> } }).__cfg;
 const C = (B as Record<string, unknown>)[cfg.component] as Parameters<typeof createElement>[0] | undefined;
 const root = document.getElementById("root");
@@ -5297,12 +5714,12 @@ body{margin:0;background:rgb(${backdrop.join(",")})}
             return name === void 0 ? c : { ...c, name };
           });
           if (opts.evidenceDir !== void 0) {
-            writeFileSync6(path17.join(opts.evidenceDir, `${cfg.rep}-render.png`), scored);
-            writeFileSync6(path17.join(opts.evidenceDir, `${cfg.rep}-ref.png`), ref);
-            writeFileSync6(path17.join(opts.evidenceDir, `${cfg.rep}-diff.png`), diffPng(scored, ref));
+            writeFileSync6(path19.join(opts.evidenceDir, `${cfg.rep}-render.png`), scored);
+            writeFileSync6(path19.join(opts.evidenceDir, `${cfg.rep}-ref.png`), ref);
+            writeFileSync6(path19.join(opts.evidenceDir, `${cfg.rep}-diff.png`), diffPng(scored, ref));
             for (const [i, c] of absent.slice(0, 3).entries()) {
-              writeFileSync6(path17.join(opts.evidenceDir, `${cfg.rep}-absent-${i}-ref.png`), zoomCrop(ref, c));
-              writeFileSync6(path17.join(opts.evidenceDir, `${cfg.rep}-absent-${i}-render.png`), zoomCrop(scored, c));
+              writeFileSync6(path19.join(opts.evidenceDir, `${cfg.rep}-absent-${i}-ref.png`), zoomCrop(ref, c));
+              writeFileSync6(path19.join(opts.evidenceDir, `${cfg.rep}-absent-${i}-render.png`), zoomCrop(scored, c));
             }
           }
           return {
@@ -5366,6 +5783,7 @@ var init_bundle_score = __esm({
     "use strict";
     init_runtime();
     init_browser();
+    init_candidate_css();
     init_src();
     init_effect_geometry();
     init_image_diff();
@@ -5410,8 +5828,6 @@ var init_prelude = __esm({
 });
 
 // packages/verify/src/parity.ts
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "node:fs";
-import path18 from "node:path";
 import { chromium as chromium6 } from "playwright-core";
 function getFontFaces3() {
   _fontFaces3 ??= fontFaceCss();
@@ -5440,7 +5856,7 @@ async function checkHoverParity(task, bundleDir, authority, opts = {}) {
   const deadlineMs = timeoutMs + 1e4;
   const js = await compileMount(task, bundleDir);
   if (typeof js !== "string") return configs.map((c) => ({ id: `parity:${c.rep}`, pass: false, detail: js.error }));
-  const css = ["tokens.css", "styles.css"].map((f) => path18.join(bundleDir, f)).filter((f) => existsSync13(f)).map((f) => readFileSync10(f, "utf8")).join("\n");
+  const css = candidateCss(bundleDir);
   const server = await chromium6.launchServer({ executablePath: resolveChrome(), headless: true, args: mountArgs() });
   const browser = await chromium6.connect(server.wsEndpoint());
   const results = [];
@@ -5537,6 +5953,7 @@ var init_parity = __esm({
   "packages/verify/src/parity.ts"() {
     "use strict";
     init_browser();
+    init_candidate_css();
     init_behavior();
     init_font_faces();
     init_mount_limits();
@@ -5546,8 +5963,8 @@ var init_parity = __esm({
 
 // packages/verify/src/composition.ts
 import { createRequire as createRequire2 } from "node:module";
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "node:fs";
-import path19 from "node:path";
+import { existsSync as existsSync15 } from "node:fs";
+import path20 from "node:path";
 import { build as build6 } from "esbuild";
 import { chromium as chromium7 } from "playwright-core";
 function getFontFaces4() {
@@ -5555,9 +5972,9 @@ function getFontFaces4() {
   return _fontFaces4;
 }
 async function compileInstrumentedMount(task, bundleDir) {
-  const entryTsx = path19.join(bundleDir, task.entry);
-  if (!existsSync14(entryTsx)) return { error: `${task.entry} missing` };
-  const requireFromVerify = createRequire2(path19.join(VERIFY_PKG_DIR, "package.json"));
+  const entryTsx = path20.join(bundleDir, task.entry);
+  if (!existsSync15(entryTsx)) return { error: `${task.entry} missing` };
+  const requireFromVerify = createRequire2(path20.join(VERIFY_PKG_DIR, "package.json"));
   let realJsxPath;
   try {
     realJsxPath = requireFromVerify.resolve("react/jsx-runtime");
@@ -5568,7 +5985,7 @@ async function compileInstrumentedMount(task, bundleDir) {
 import { createElement } from "react";
 import { createRoot } from "react-dom/client";
 import { __registerParts } from "react/jsx-runtime";
-import * as B from ${JSON.stringify(path19.resolve(entryTsx))};
+import * as B from ${JSON.stringify(path20.resolve(entryTsx))};
 const cfg = (window as unknown as { __cfg: { component: string; props: Record<string, unknown>; partComponents: string[] } }).__cfg;
 const pairs: Array<[unknown, string]> = [];
 for (const name of cfg.partComponents) {
@@ -5623,7 +6040,7 @@ function expectedParts(task, roles, mainSlug) {
 }
 function interiorRegions(setDir, roles) {
   const mains = roles.main;
-  const withInterior = mains.filter((m) => existsSync14(path19.join(setDir, m, "get_metadata_interior.json")));
+  const withInterior = mains.filter((m) => existsSync15(path20.join(setDir, m, "get_metadata_interior.json")));
   if (withInterior.length === 0) {
     return { unavailable: "no interior geometry recorded for any main (pre-obligation set) \u2014 re-record with `tendril record` to enable crop checks" };
   }
@@ -5640,7 +6057,7 @@ async function checkCropComposition(task, bundleDir, regions, opts = {}) {
   if (typeof js !== "string") {
     return regions.map((r) => ({ id: cropId(r), pass: false, similarity: 0, inkRecall: 0, detail: js.error }));
   }
-  const css = ["tokens.css", "styles.css"].map((f) => path19.join(bundleDir, f)).filter((f) => existsSync14(f)).map((f) => readFileSync11(f, "utf8")).join("\n");
+  const css = candidateCss(bundleDir);
   const server = await chromium7.launchServer({ executablePath: resolveChrome(), headless: true, args: mountArgs() });
   const browser = await chromium7.connect(server.wsEndpoint());
   const PAD = 4;
@@ -5745,7 +6162,7 @@ async function checkStructuralComposition(task, bundleDir, roles, opts = {}) {
   const deadlineMs = timeoutMs + 1e4;
   const js = await compileInstrumentedMount(task, bundleDir);
   if (typeof js !== "string") return [...results, ...mains.map((m) => ({ id: `composition:${m}`, pass: false, detail: js.error }))];
-  const css = ["tokens.css", "styles.css"].map((f) => path19.join(bundleDir, f)).filter((f) => existsSync14(f)).map((f) => readFileSync11(f, "utf8")).join("\n");
+  const css = candidateCss(bundleDir);
   const server = await chromium7.launchServer({ executablePath: resolveChrome(), headless: true, args: mountArgs() });
   const browser = await chromium7.connect(server.wsEndpoint());
   try {
@@ -5814,6 +6231,7 @@ var init_composition = __esm({
     "use strict";
     init_runtime();
     init_browser();
+    init_candidate_css();
     init_font_faces();
     init_image_diff();
     init_mount_limits();
@@ -5835,17 +6253,17 @@ export const jsxs = (t, p, k) => real.jsxs(t, inject(t, p), k);
 });
 
 // packages/verify/src/occlusion.ts
-import { existsSync as existsSync15 } from "node:fs";
-import path20 from "node:path";
+import { existsSync as existsSync16 } from "node:fs";
+import path21 from "node:path";
 import { build as build7 } from "esbuild";
 import { chromium as chromium8 } from "playwright-core";
 async function compileTwoUp(task, bundleDir) {
-  const entryTsx = path20.join(bundleDir, task.entry);
-  if (!existsSync15(entryTsx)) return { error: `${task.entry} missing` };
+  const entryTsx = path21.join(bundleDir, task.entry);
+  if (!existsSync16(entryTsx)) return { error: `${task.entry} missing` };
   const src = `
 import { createElement } from "react";
 import { createRoot } from "react-dom/client";
-import * as B from ${JSON.stringify(path20.resolve(entryTsx))};
+import * as B from ${JSON.stringify(path21.resolve(entryTsx))};
 const cfg = (window as unknown as { __cfg: { component: string; props: Record<string, unknown> } }).__cfg;
 const C = (B as Record<string, unknown>)[cfg.component] as Parameters<typeof createElement>[0] | undefined;
 for (const id of ["first", "second"]) {
@@ -6019,32 +6437,33 @@ var init_src4 = __esm({
     init_font_resolve();
     init_paths();
     init_parity();
+    init_candidate_css();
     init_composition();
     init_occlusion();
   }
 });
 
 // packages/cli/src/environment.ts
-import { existsSync as existsSync16, readFileSync as readFileSync12 } from "node:fs";
-import path21 from "node:path";
-import { createHash as createHash3 } from "node:crypto";
+import { existsSync as existsSync17, readFileSync as readFileSync13 } from "node:fs";
+import path22 from "node:path";
+import { createHash as createHash4 } from "node:crypto";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function cliVersion() {
   try {
-    return JSON.parse(readFileSync12(path21.join(path21.dirname(fileURLToPath5(import.meta.url)), "..", "package.json"), "utf8")).version ?? "dev";
+    return JSON.parse(readFileSync13(path22.join(path22.dirname(fileURLToPath5(import.meta.url)), "..", "package.json"), "utf8")).version ?? "dev";
   } catch {
     return "dev";
   }
 }
 function environmentStamp(taskFamilies) {
-  const manifestPath2 = path21.join(fontCacheDir(), "manifest.json");
+  const manifestPath2 = path22.join(fontCacheDir(), "manifest.json");
   let fontsHash = null;
-  if (existsSync16(manifestPath2)) {
+  if (existsSync17(manifestPath2)) {
     try {
-      const entries = JSON.parse(readFileSync12(manifestPath2, "utf8"));
+      const entries = JSON.parse(readFileSync13(manifestPath2, "utf8"));
       const scoped = taskFamilies === void 0 || taskFamilies === null ? entries : entries.filter((f) => taskFamilies.some((fam) => fam.toLowerCase() === f.family.toLowerCase()));
       const faces = scoped.map((f) => `${f.family}:${f.weight}:${f.sha256}`).sort();
-      fontsHash = faces.length === 0 ? null : createHash3("sha256").update(faces.join("\n")).digest("hex").slice(0, 16);
+      fontsHash = faces.length === 0 ? null : createHash4("sha256").update(faces.join("\n")).digest("hex").slice(0, 16);
     } catch {
       fontsHash = null;
     }
@@ -6085,8 +6504,8 @@ var init_describe = __esm({
 });
 
 // packages/cli/src/env.ts
-import { existsSync as existsSync17, readFileSync as readFileSync13 } from "node:fs";
-import path22 from "node:path";
+import { existsSync as existsSync18, readFileSync as readFileSync14 } from "node:fs";
+import path23 from "node:path";
 function parseEnv(content) {
   const entries = /* @__PURE__ */ new Map();
   for (const line of content.split("\n")) {
@@ -6098,9 +6517,9 @@ function parseEnv(content) {
 function resolveCredential(name) {
   const fromProcess = process.env[name];
   if (fromProcess) return fromProcess;
-  const envPath = path22.resolve(process.env["INIT_CWD"] ?? process.cwd(), ".env");
-  if (!existsSync17(envPath)) return void 0;
-  return parseEnv(readFileSync13(envPath, "utf8")).get(name);
+  const envPath = path23.resolve(process.env["INIT_CWD"] ?? process.cwd(), ".env");
+  if (!existsSync18(envPath)) return void 0;
+  return parseEnv(readFileSync14(envPath, "utf8")).get(name);
 }
 var init_env = __esm({
   "packages/cli/src/env.ts"() {
@@ -6160,17 +6579,17 @@ var init_output = __esm({
 });
 
 // packages/cli/src/entitlement.ts
-import { chmodSync, existsSync as existsSync18, mkdirSync as mkdirSync4, readFileSync as readFileSync14, writeFileSync as writeFileSync7 } from "node:fs";
+import { chmodSync, existsSync as existsSync19, mkdirSync as mkdirSync4, readFileSync as readFileSync15, writeFileSync as writeFileSync7 } from "node:fs";
 import crypto from "node:crypto";
 import os4 from "node:os";
-import path23 from "node:path";
+import path24 from "node:path";
 function entitlementPath() {
-  return process.env["TENDRIL_ENTITLEMENT_PATH"] ?? path23.join(os4.homedir(), ".tendril", "entitlement.json");
+  return process.env["TENDRIL_ENTITLEMENT_PATH"] ?? path24.join(os4.homedir(), ".tendril", "entitlement.json");
 }
 function readStoredEntitlement(file = entitlementPath()) {
-  if (!existsSync18(file)) return void 0;
+  if (!existsSync19(file)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync14(file, "utf8"));
+    const parsed = JSON.parse(readFileSync15(file, "utf8"));
     if (typeof parsed.token !== "string" || typeof parsed.lastRefreshAt !== "number") return void 0;
     return { token: parsed.token, lastRefreshAt: parsed.lastRefreshAt };
   } catch {
@@ -6178,7 +6597,7 @@ function readStoredEntitlement(file = entitlementPath()) {
   }
 }
 function writeStoredEntitlement(stored, file = entitlementPath()) {
-  mkdirSync4(path23.dirname(file), { recursive: true });
+  mkdirSync4(path24.dirname(file), { recursive: true });
   writeFileSync7(file, `${JSON.stringify(stored, null, 2)}
 `);
   chmodSync(file, 384);
@@ -6263,9 +6682,9 @@ var init_entitlement = __esm({
 
 // packages/cli/src/commands/doctor.ts
 import { spawnSync } from "node:child_process";
-import { existsSync as existsSync19, readFileSync as readFileSync15, readdirSync as readdirSync4 } from "node:fs";
+import { existsSync as existsSync20, readFileSync as readFileSync16, readdirSync as readdirSync6 } from "node:fs";
 import os5 from "node:os";
-import path24 from "node:path";
+import path25 from "node:path";
 function withDeadline(work, ms) {
   return Promise.race([
     work,
@@ -6325,19 +6744,19 @@ async function runDoctorChecks(options) {
       remediation: "Install Google Chrome (or Chromium), or set CHROME_PATH to a Chromium-family browser binary."
     });
   }
-  const fontManifest = path24.join(fontCacheDir(), "manifest.json");
+  const fontManifest = path25.join(fontCacheDir(), "manifest.json");
   checks.push(
-    existsSync19(fontManifest) ? { name: "font-cache", ok: true, detail: `resolved font cache at ${fontCacheDir()} (${JSON.parse(readFileSync15(fontManifest, "utf8")).length} faces)` } : {
+    existsSync20(fontManifest) ? { name: "font-cache", ok: true, detail: `resolved font cache at ${fontCacheDir()} (${JSON.parse(readFileSync16(fontManifest, "utf8")).length} faces)` } : {
       name: "font-cache",
       ok: true,
       detail: `font cache empty at ${fontCacheDir()} \u2014 normal on a fresh machine; faces resolve per design system at first use`,
       remediation: `Nothing to do now: \`${tendrilCommand("fonts resolve --set <recording-dir>")}\` fetches exactly what a recording declares, and generate/verify name that command \u2014 with the set filled in \u2014 when they need it.`
     }
   );
-  const pluginRoot = path24.join(os5.homedir(), ".claude", "plugins", "cache", "tendrilapp", "tendril");
-  if (existsSync19(pluginRoot)) {
+  const pluginRoot = path25.join(os5.homedir(), ".claude", "plugins", "cache", "tendrilapp", "tendril");
+  if (existsSync20(pluginRoot)) {
     try {
-      const versions = readdirSync4(pluginRoot).filter((v) => /^\d+\.\d+\.\d+$/.test(v));
+      const versions = readdirSync6(pluginRoot).filter((v) => /^\d+\.\d+\.\d+$/.test(v));
       const newest = versions.sort((a, b) => versionIsNewer(a, b) ? 1 : -1)[0];
       if (newest !== void 0) {
         const skewed = versionIsNewer(newest, cliVersion());
@@ -6482,7 +6901,7 @@ var init_doctor = __esm({
 });
 
 // packages/llm/src/model-config.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 function resolveModel(config, requestedId) {
   const entry = config.allowlist.find((m) => m.id === requestedId);
   if (entry) return { ok: true, entry };
@@ -6504,46 +6923,46 @@ var ModelStatusSchema, ModelEntrySchema, ModelConfigSchema, DEFAULT_MODEL_CONFIG
 var init_model_config = __esm({
   "packages/llm/src/model-config.ts"() {
     "use strict";
-    ModelStatusSchema = z6.enum(["verified", "degraded"]);
-    ModelEntrySchema = z6.object({
+    ModelStatusSchema = z7.enum(["verified", "degraded"]);
+    ModelEntrySchema = z7.object({
       /** OpenRouter model id, e.g. "deepseek/deepseek-v4-flash". */
-      id: z6.string(),
+      id: z7.string(),
       status: ModelStatusSchema,
       /** Roles this model may fill in the pipeline. */
-      roles: z6.array(z6.enum(["bulk", "polish"])),
+      roles: z7.array(z7.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: z6.boolean().default(false),
+      vision: z7.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: z6.object({
+      adapter: z7.object({
         /** Minimum completion budget the model needs to emit full files. */
-        maxTokens: z6.number().optional(),
+        maxTokens: z7.number().optional(),
         /** "mandatory": provider refuses reasoning-off; budget accordingly. */
-        reasoning: z6.enum(["mandatory", "optional", "none"]).optional()
+        reasoning: z7.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: z6.string().optional()
+      evidence: z7.string().optional()
     });
-    ModelConfigSchema = z6.object({
+    ModelConfigSchema = z7.object({
       /** Default model for codegen + repair (pipeline steps 4–5, facts path). */
-      bulk: z6.string(),
+      bulk: z7.string(),
       /** Optional premium polish model (pipeline step 6, aesthetics/naming only). */
-      polish: z6.string().optional(),
+      polish: z7.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: z6.string().optional(),
+      curatedDefault: z7.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: z6.string().optional(),
-      allowlist: z6.array(ModelEntrySchema)
+      escalationTarget: z7.string().optional(),
+      allowlist: z7.array(ModelEntrySchema)
     });
     DEFAULT_MODEL_CONFIG = {
       bulk: "google/gemini-3.1-flash-lite",
@@ -6722,7 +7141,7 @@ var init_openrouter = __esm({
 });
 
 // packages/llm/src/semantics.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 function portable(node) {
   if (Array.isArray(node)) return node.map(portable);
   if (typeof node !== "object" || node === null) return node;
@@ -6746,7 +7165,7 @@ function portable(node) {
   return out;
 }
 function toPortableJsonSchema(schema) {
-  return portable(z7.toJSONSchema(schema));
+  return portable(z8.toJSONSchema(schema));
 }
 function semanticsJsonSchema() {
   return toPortableJsonSchema(SemanticsSchema);
@@ -6761,18 +7180,18 @@ var PropTypeSchema, SemanticsSchema, CodegenOutputSchema, DocsOutputSchema;
 var init_semantics = __esm({
   "packages/llm/src/semantics.ts"() {
     "use strict";
-    PropTypeSchema = z7.discriminatedUnion("kind", [
-      z7.object({ kind: z7.literal("enum"), values: z7.array(z7.string()).min(1) }),
-      z7.object({ kind: z7.literal("boolean") }),
-      z7.object({ kind: z7.literal("string") }),
-      z7.object({ kind: z7.literal("reactNode") }),
-      z7.object({ kind: z7.literal("handler") })
+    PropTypeSchema = z8.discriminatedUnion("kind", [
+      z8.object({ kind: z8.literal("enum"), values: z8.array(z8.string()).min(1) }),
+      z8.object({ kind: z8.literal("boolean") }),
+      z8.object({ kind: z8.literal("string") }),
+      z8.object({ kind: z8.literal("reactNode") }),
+      z8.object({ kind: z8.literal("handler") })
     ]);
-    SemanticsSchema = z7.object({
+    SemanticsSchema = z8.object({
       /** PascalCase component name. */
-      componentName: z7.string().regex(/^[A-Z][A-Za-z0-9]*$/),
+      componentName: z8.string().regex(/^[A-Z][A-Za-z0-9]*$/),
       /** Semantic HTML element for the root node. */
-      element: z7.enum([
+      element: z8.enum([
         "button",
         "a",
         "div",
@@ -6786,33 +7205,33 @@ var init_semantics = __esm({
         "ul",
         "li"
       ]),
-      props: z7.array(
-        z7.object({
-          name: z7.string().regex(/^[a-z][A-Za-z0-9]*$/),
+      props: z8.array(
+        z8.object({
+          name: z8.string().regex(/^[a-z][A-Za-z0-9]*$/),
           type: PropTypeSchema,
-          required: z7.boolean(),
+          required: z8.boolean(),
           /** nullish, not optional: models routinely encode "no default" as
            * null (observed live: kimi-k2.7-code, Carbon run 8). */
-          defaultValue: z7.string().nullish()
+          defaultValue: z8.string().nullish()
         })
       ),
       /** Variant axes that become discriminated unions (invalid combos must not compile). */
-      discriminatedUnions: z7.array(
-        z7.object({
-          discriminant: z7.string(),
-          arms: z7.array(
-            z7.object({
-              value: z7.string(),
+      discriminatedUnions: z8.array(
+        z8.object({
+          discriminant: z8.string(),
+          arms: z8.array(
+            z8.object({
+              value: z8.string(),
               /** Props only valid for this arm. */
-              extraProps: z7.array(z7.string())
+              extraProps: z8.array(z8.string())
             })
           )
         })
       ),
-      a11y: z7.object({
-        role: z7.string().nullish(),
-        keyboard: z7.array(z7.string()),
-        aria: z7.array(z7.string())
+      a11y: z8.object({
+        role: z8.string().nullish(),
+        keyboard: z8.array(z8.string()),
+        aria: z8.array(z8.string())
       }),
       /**
        * How each Figma axis value is realized through the generated API —
@@ -6821,29 +7240,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: z7.array(
-        z7.object({
-          axis: z7.string(),
-          value: z7.string(),
-          prop: z7.string(),
-          propValue: z7.union([z7.string(), z7.boolean()])
+      variantMapping: z8.array(
+        z8.object({
+          axis: z8.string(),
+          value: z8.string(),
+          prop: z8.string(),
+          propValue: z8.union([z8.string(), z8.boolean()])
         })
       )
     });
-    CodegenOutputSchema = z7.object({
+    CodegenOutputSchema = z8.object({
       /** Component source (.tsx). Token-only styling via the provided CSS file. */
-      tsx: z7.string().min(1),
+      tsx: z8.string().min(1),
       /** Stylesheet (.css) — themable properties reference var(--token) only. */
-      css: z7.string().min(1)
+      css: z8.string().min(1)
     });
-    DocsOutputSchema = z7.object({
-      usageMd: z7.string().min(1),
-      aiHints: z7.object({ selectionCriteria: z7.array(z7.string()).min(1) }),
-      antiPatterns: z7.array(
-        z7.object({ scenario: z7.string(), reason: z7.string(), alternative: z7.string() })
+    DocsOutputSchema = z8.object({
+      usageMd: z8.string().min(1),
+      aiHints: z8.object({ selectionCriteria: z8.array(z8.string()).min(1) }),
+      antiPatterns: z8.array(
+        z8.object({ scenario: z8.string(), reason: z8.string(), alternative: z8.string() })
       ),
-      composition: z7.array(z7.string()),
-      examples: z7.array(z7.object({ title: z7.string(), code: z7.string() }))
+      composition: z8.array(z8.string()),
+      examples: z8.array(z8.object({ title: z8.string(), code: z8.string() }))
     });
   }
 });
@@ -7313,56 +7732,56 @@ var init_src5 = __esm({
 });
 
 // packages/metadata/src/component-json.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var TokenUseSchema, AntiPatternSchema, ComponentJsonSchema;
 var init_component_json = __esm({
   "packages/metadata/src/component-json.ts"() {
     "use strict";
-    TokenUseSchema = z8.object({
+    TokenUseSchema = z9.object({
       /** DTCG token path, e.g. "color.primary". */
-      path: z8.string(),
-      cssVar: z8.string(),
-      usage: z8.string()
-    });
-    AntiPatternSchema = z8.object({
-      scenario: z8.string(),
-      reason: z8.string(),
-      alternative: z8.string()
-    });
-    ComponentJsonSchema = z8.object({
-      name: z8.string(),
-      version: z8.string(),
+      path: z9.string(),
+      cssVar: z9.string(),
+      usage: z9.string()
+    });
+    AntiPatternSchema = z9.object({
+      scenario: z9.string(),
+      reason: z9.string(),
+      alternative: z9.string()
+    });
+    ComponentJsonSchema = z9.object({
+      name: z9.string(),
+      version: z9.string(),
       // --- Structural: generated from code by react-docgen. Never hand-edited. ---
-      props: z8.array(
-        z8.object({
-          name: z8.string(),
-          type: z8.string(),
-          required: z8.boolean(),
-          defaultValue: z8.string().optional(),
-          description: z8.string().optional()
+      props: z9.array(
+        z9.object({
+          name: z9.string(),
+          type: z9.string(),
+          required: z9.boolean(),
+          defaultValue: z9.string().optional(),
+          description: z9.string().optional()
         })
       ),
-      variants: z8.record(z8.string(), z8.array(z8.string())),
-      states: z8.array(z8.string()),
-      tokensUsed: z8.array(TokenUseSchema),
-      a11y: z8.object({
-        role: z8.string().optional(),
-        keyboard: z8.array(z8.string()),
-        aria: z8.array(z8.string())
+      variants: z9.record(z9.string(), z9.array(z9.string())),
+      states: z9.array(z9.string()),
+      tokensUsed: z9.array(TokenUseSchema),
+      a11y: z9.object({
+        role: z9.string().optional(),
+        keyboard: z9.array(z9.string()),
+        aria: z9.array(z9.string())
       }),
       // --- LLM-authored, deterministically validated. ---
-      aiHints: z8.object({
-        selectionCriteria: z8.array(z8.string())
+      aiHints: z9.object({
+        selectionCriteria: z9.array(z9.string())
       }),
-      antiPatterns: z8.array(AntiPatternSchema),
-      composition: z8.array(z8.string()),
-      examples: z8.array(z8.object({ title: z8.string(), code: z8.string() })),
+      antiPatterns: z9.array(AntiPatternSchema),
+      composition: z9.array(z9.string()),
+      examples: z9.array(z9.object({ title: z9.string(), code: z9.string() })),
       // --- Provenance. ---
-      generated: z8.object({
-        tool: z8.literal("tendril"),
-        toolVersion: z8.string(),
-        model: z8.string(),
-        modelStatus: z8.enum(["verified", "degraded"])
+      generated: z9.object({
+        tool: z9.literal("tendril"),
+        toolVersion: z9.string(),
+        model: z9.string(),
+        modelStatus: z9.enum(["verified", "degraded"])
       })
     });
   }
@@ -7448,7 +7867,7 @@ var init_extract = __esm({
 });
 
 // packages/metadata/src/recording-set.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 function roleLossToken(loss) {
   return loss.kind === "main" ? `main:${loss.main}` : `part:${loss.part}${EDGE_ARROW}${loss.main}`;
 }
@@ -7511,58 +7930,58 @@ var init_recording_set = __esm({
   "packages/metadata/src/recording-set.ts"() {
     "use strict";
     RECORDING_SET_VERSION = 1;
-    EnvelopeSchema = z9.object({
-      content: z9.array(
-        z9.object({
-          type: z9.string().optional(),
-          text: z9.string().optional(),
-          data: z9.string().optional(),
-          mimeType: z9.string().optional()
+    EnvelopeSchema = z10.object({
+      content: z10.array(
+        z10.object({
+          type: z10.string().optional(),
+          text: z10.string().optional(),
+          data: z10.string().optional(),
+          mimeType: z10.string().optional()
         })
       )
     });
-    RepEntrySchema = z9.object({
+    RepEntrySchema = z10.object({
       /** Directory slug under the set root. */
-      slug: z9.string().min(1),
+      slug: z10.string().min(1),
       /** Figma node id of the recorded symbol, e.g. "2222:10354". */
-      nodeId: z9.string().regex(/^\d+:\d+$/),
+      nodeId: z10.string().regex(/^\d+:\d+$/),
       /** Source frame node id (multi-frame kits record where each symbol
        * lives — the shadcn Calendar spans four frames). */
-      sourceFrame: z9.string().regex(/^\d+:\d+$/).optional()
+      sourceFrame: z10.string().regex(/^\d+:\d+$/).optional()
     });
-    RolesSchema = z9.object({
+    RolesSchema = z10.object({
       /** Slugs of reps whose symbols are MAIN components. */
-      main: z9.array(z9.string()),
+      main: z10.array(z10.string()),
       /** slug → the main slugs it is a part of. */
-      parts: z9.record(z9.string(), z9.object({ partOf: z9.array(z9.string()).min(1) })),
+      parts: z10.record(z10.string(), z10.object({ partOf: z10.array(z10.string()).min(1) })),
       /** External/unrecorded component references discovered during
        * derivation — disclosed, never silently dropped (Calendar's Icon
        * Buttons; unrecorded base variants). */
-      external: z9.array(z9.string()).optional(),
+      external: z10.array(z10.string()).optional(),
       /** Where this graph came from. A graph with empty `parts` makes the
        * structural composition check return an affirmative PASS, so a
        * human-authored override and a derived graph must never be
        * indistinguishable in a report. The CLI stamps this itself — a
        * supplied roles file cannot claim "derived" for itself. */
-      rolesSource: z9.enum(["derived", "human-override"]).optional(),
+      rolesSource: z10.enum(["derived", "human-override"]).optional(),
       /** Losses in the DERIVED relation a human override deliberately
        * accepts, one token per loss (`roleLossToken`). Named one by one on
        * purpose: emptying out what composition measures — by dropping a
        * main, or by dropping/re-pointing a part→main edge — is exactly what
        * turns composition into a vacuous pass, so it is an acceptance
        * someone signs rather than an omission nobody notices. */
-      narrowingAccepted: z9.array(z9.string()).optional()
+      narrowingAccepted: z10.array(z10.string()).optional()
     });
     EDGE_ARROW = "->";
-    RecordingSetManifestSchema = z9.object({
-      version: z9.literal(RECORDING_SET_VERSION),
+    RecordingSetManifestSchema = z10.object({
+      version: z10.literal(RECORDING_SET_VERSION),
       /** Human-readable component/system name. */
-      component: z9.string().min(1),
+      component: z10.string().min(1),
       /** Source frames: node id → short description. */
-      sourceFrames: z9.record(z9.string(), z9.string()).optional(),
-      reps: z9.array(RepEntrySchema).min(1),
+      sourceFrames: z10.record(z10.string(), z10.string()).optional(),
+      reps: z10.array(RepEntrySchema).min(1),
       /** Honesty contract: what was NOT recorded, in prose. */
-      notRecorded: z9.string().optional(),
+      notRecorded: z10.string().optional(),
       roles: RolesSchema.optional()
     });
     REQUIRED_REP_FILES = ["get_design_context.json", "get_metadata.json", "get_screenshot.json"];
@@ -7570,7 +7989,7 @@ var init_recording_set = __esm({
 });
 
 // packages/metadata/src/bundle.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 function readBundleManifest(raw) {
   if (Buffer.byteLength(raw, "utf8") > MAX_BUNDLE_MANIFEST_BYTES) {
     return { issues: [{ severity: "error", message: `component.json exceeds the ${MAX_BUNDLE_MANIFEST_BYTES}-byte ingest cap` }] };
@@ -7642,94 +8061,94 @@ var init_bundle = __esm({
     "use strict";
     init_recording_set();
     BUNDLE_VERSION = 1;
-    ConfigStatusSchema = z10.enum(["certified", "pass", "fail", "fallback-unverified", "unverified", "part-unverified-standalone"]);
-    PinnedPropSchema = z10.object({
-      name: z10.string(),
-      type: z10.string(),
-      required: z10.boolean(),
-      default: z10.string().optional()
-    });
-    PropAdapterSchema = z10.record(
-      z10.string(),
-      z10.object({
-        component: z10.string(),
-        props: z10.record(z10.string(), z10.unknown())
+    ConfigStatusSchema = z11.enum(["certified", "pass", "fail", "fallback-unverified", "unverified", "part-unverified-standalone"]);
+    PinnedPropSchema = z11.object({
+      name: z11.string(),
+      type: z11.string(),
+      required: z11.boolean(),
+      default: z11.string().optional()
+    });
+    PropAdapterSchema = z11.record(
+      z11.string(),
+      z11.object({
+        component: z11.string(),
+        props: z11.record(z11.string(), z11.unknown())
       })
     );
-    RequiredFontSchema = z10.object({
-      family: z10.string(),
-      weight: z10.number(),
-      source: z10.string(),
-      sha256: z10.string()
-    });
-    ConfigClaimSchema = z10.object({
-      rep: z10.string(),
-      similarity: z10.number(),
-      inkRecall: z10.number(),
+    RequiredFontSchema = z11.object({
+      family: z11.string(),
+      weight: z11.number(),
+      source: z11.string(),
+      sha256: z11.string()
+    });
+    ConfigClaimSchema = z11.object({
+      rep: z11.string(),
+      similarity: z11.number(),
+      inkRecall: z11.number(),
       status: ConfigStatusSchema
     });
-    BehaviorClaimSchema = z10.object({
-      id: z10.string(),
-      pass: z10.boolean(),
-      detail: z10.string().optional()
+    BehaviorClaimSchema = z11.object({
+      id: z11.string(),
+      pass: z11.boolean(),
+      detail: z11.string().optional()
     });
-    BundleProvenanceSchema = z10.object({
+    BundleProvenanceSchema = z11.object({
       /** Engine id that produced the accepted candidate. */
-      engine: z10.string(),
+      engine: z11.string(),
       /** Resolved model id (curated engine) or agent identity, when known. */
-      model: z10.string().optional(),
-      recordingSet: z10.object({
+      model: z11.string().optional(),
+      recordingSet: z11.object({
         /** Set path as seen at generate time — informational, not trusted. */
-        path: z10.string(),
+        path: z11.string(),
         /** Kit/component name from the set manifest. */
-        component: z10.string(),
+        component: z11.string(),
         /** Founder-visible license posture of the recorded kit, if noted. */
-        licenseNote: z10.string().optional(),
+        licenseNote: z11.string().optional(),
         /** Content hash over the set manifest + rep envelopes (the identity
          * verify compares against, not the path). */
-        hash: z10.string()
+        hash: z11.string()
       }),
-      environment: z10.object({
-        chrome: z10.string(),
+      environment: z11.object({
+        chrome: z11.string(),
         // chromeVersion joined the stamp when a path alone proved
         // insufficient identity (two builds, one path, incomparable
         // numbers); optional so pre-epoch bundles keep validating.
-        chromeVersion: z10.string().nullable().optional(),
-        fontsManifestSha256: z10.string().nullable(),
+        chromeVersion: z11.string().nullable().optional(),
+        fontsManifestSha256: z11.string().nullable(),
         // Run 11: a bundle scored under a substitute face carried CSS
         // compensation (font-variation-settings tuned to the substitute)
         // with nothing marking it conditional — the provenance now names
         // the families that were substituted at scoring time. Optional so
         // pre-0.1.19 bundles keep validating; absent means none.
-        substitutedFamilies: z10.array(z10.string()).optional()
+        substitutedFamilies: z11.array(z11.string()).optional()
       }),
       /** Coverage denominator (Q2 honesty): recorded vs full-lattice size
        * when the lattice is known (null when the kit exposes no lattice). */
-      coverage: z10.object({
-        recordedConfigs: z10.number().int().nonnegative(),
-        latticeConfigs: z10.number().int().positive().nullable()
+      coverage: z11.object({
+        recordedConfigs: z11.number().int().nonnegative(),
+        latticeConfigs: z11.number().int().positive().nullable()
       }),
-      generatedAt: z10.string(),
-      spentUsd: z10.number().optional()
+      generatedAt: z11.string(),
+      spentUsd: z11.number().optional()
     });
-    BundleComponentJsonSchema = z10.object({
-      bundleVersion: z10.literal(BUNDLE_VERSION),
-      name: z10.string().min(1),
+    BundleComponentJsonSchema = z11.object({
+      bundleVersion: z11.literal(BUNDLE_VERSION),
+      name: z11.string().min(1),
       /** Entry module file name (e.g. "Button.tsx"). */
-      entry: z10.string().min(1),
-      props: z10.array(PinnedPropSchema),
+      entry: z11.string().min(1),
+      props: z11.array(PinnedPropSchema),
       /** data-tendril-state tokens the bundle supports (A1.3 forcing hook). */
-      forcedStates: z10.array(z10.string()),
+      forcedStates: z11.array(z11.string()),
       propAdapter: PropAdapterSchema,
-      requiredFonts: z10.array(RequiredFontSchema),
+      requiredFonts: z11.array(RequiredFontSchema),
       /** A1.2: mirrors the RECORDING's role manifest — verify takes the
        * graph from the recording, so a bundle declaring no parts dodges
        * nothing. Absent when the recording claims no roles. */
       composition: RolesSchema.optional(),
-      configStatuses: z10.array(ConfigClaimSchema),
-      behaviorClaims: z10.array(BehaviorClaimSchema).optional(),
+      configStatuses: z11.array(ConfigClaimSchema),
+      behaviorClaims: z11.array(BehaviorClaimSchema).optional(),
       provenance: BundleProvenanceSchema,
-      trustStatement: z10.string().min(1)
+      trustStatement: z11.string().min(1)
     });
     MAX_BUNDLE_MANIFEST_BYTES = 1e6;
     MAX_BUNDLE_SOURCE_BYTES = 5e6;
@@ -7861,9 +8280,9 @@ __export(record_exports, {
   runRecordPlan: () => runRecordPlan,
   runRecordStatus: () => runRecordStatus
 });
-import { existsSync as existsSync21, mkdtempSync as mkdtempSync2, readFileSync as readFileSync17, readdirSync as readdirSync6 } from "node:fs";
+import { existsSync as existsSync22, mkdtempSync as mkdtempSync2, readFileSync as readFileSync18, readdirSync as readdirSync8 } from "node:fs";
 import os6 from "node:os";
-import path27 from "node:path";
+import path28 from "node:path";
 import { writeFileSync as writeFileSync9 } from "node:fs";
 function recordsInteractionState(reports) {
   const evident = (s) => stateTokens(s).some((t) => INTERACTION_EVIDENCE_VALUES.has(t));
@@ -7886,7 +8305,7 @@ function interactionDisclosure(component, reports) {
   };
 }
 function symbolsFromMetadataEnvelope(file, sourceFrame) {
-  const env = JSON.parse(readFileSync17(file, "utf8"));
+  const env = JSON.parse(readFileSync18(file, "utf8"));
   const text = env.content.map((c) => c.text ?? "").join("\n");
   const symbols = [];
   const walk2 = (node, ancestor) => {
@@ -7944,7 +8363,7 @@ function runRecordPlan(opts) {
   if (rawFile !== void 0) {
     try {
       const envelope = rawEnvelopeFromFile(rawFile, opts.metadataRawPartsFile !== void 0);
-      const tmp = path27.join(mkdtempSync2(path27.join(os6.tmpdir(), "tendril-plan-meta-")), "get_metadata.json");
+      const tmp = path28.join(mkdtempSync2(path28.join(os6.tmpdir(), "tendril-plan-meta-")), "get_metadata.json");
       writeFileSync9(tmp, JSON.stringify(envelope));
       metadataEntries.push({ file: tmp });
     } catch (err) {
@@ -7966,7 +8385,7 @@ function runRecordPlan(opts) {
   let metadataTruncated = false;
   for (const { file, frame } of metadataEntries) {
     try {
-      const parsed = symbolsFromMetadataEnvelope(path27.resolve(file), frame);
+      const parsed = symbolsFromMetadataEnvelope(path28.resolve(file), frame);
       symbols.push(...parsed.symbols);
       if (parsed.truncated) metadataTruncated = true;
     } catch (err) {
@@ -8000,7 +8419,7 @@ function runRecordPlan(opts) {
   if (symbols.length === 0) {
     const leads = metadataEntries.flatMap(({ file }) => {
       try {
-        const env = JSON.parse(readFileSync17(path27.resolve(file), "utf8"));
+        const env = JSON.parse(readFileSync18(path28.resolve(file), "utf8"));
         return instanceLeads(env.content.map((c) => c.text ?? "").join("\n"));
       } catch {
         return [];
@@ -8089,7 +8508,7 @@ function runRecordPlan(opts) {
         // a CLI flag and the MCP surface has no parameter for it.
         decidedBy: "HUMAN ONLY \u2014 offer it, never choose it, and you cannot run it",
         text: "Record a reduced pose set (anchor + one-factor sweeps + conflict crosses) instead of the full variant matrix. This buys calls with coverage \u2014 sampling is blind to multi-axis interactions and the report discloses the poses it skipped \u2014 so only the user may accept that trade. There is no tool parameter for it; the user runs it themselves in their own terminal, before any pose is recorded.",
-        userRuns: [`rm ${quoteArg(path27.join(opts.setDir, "recording-set.json"))}`, `${tendrilCommand(`record plan --set ${quoteArg(opts.setDir)} --component ${quoteArg(manifest.component)}`)} --sample`]
+        userRuns: [`rm ${quoteArg(path28.join(opts.setDir, "recording-set.json"))}`, `${tendrilCommand(`record plan --set ${quoteArg(opts.setDir)} --component ${quoteArg(manifest.component)}`)} --sample`]
       },
       {
         id: "larger-allowance",
@@ -8246,7 +8665,7 @@ function runRecordNext(opts) {
     const progress = payload["progress"];
     process.stdout.write(`[${progress.recordedReps}/${progress.totalReps} reps] ${payload["tool"]} for ${payload["slug"]} (node ${payload["nodeId"]})
   \u2192 ${payload["note"]}
-  \u2192 then: ${tendrilCommand(`record ingest --set ${path27.resolve(opts.setDir)} --rep ${payload["slug"]} --tool ${payload["tool"]} --file <envelope.json>`)}
+  \u2192 then: ${tendrilCommand(`record ingest --set ${path28.resolve(opts.setDir)} --rep ${payload["slug"]} --tool ${payload["tool"]} --file <envelope.json>`)}
 `);
   });
 }
@@ -8320,7 +8739,7 @@ async function autoFetchAssets(setDir, rep, envelopeText2) {
   const skipped = [];
   const failed = [];
   for (const { url, name } of assetUrlsFromEnvelopeText(envelopeText2)) {
-    if (existsSync21(path27.join(setDir, rep, name))) {
+    if (existsSync22(path28.join(setDir, rep, name))) {
       skipped.push(name);
       continue;
     }
@@ -8342,16 +8761,16 @@ async function autoFetchAssets(setDir, rep, envelopeText2) {
 }
 function rawEnvelopeFromFile(file, parts) {
   if (parts) {
-    const blocks = JSON.parse(readFileSync17(path27.resolve(file), "utf8"));
+    const blocks = JSON.parse(readFileSync18(path28.resolve(file), "utf8"));
     if (!Array.isArray(blocks) || blocks.length === 0 || blocks.some((p) => typeof p !== "string")) throw new Error("parts file must be a non-empty JSON array of strings");
     return { content: blocks.map((text) => ({ type: "text", text })) };
   }
-  return { content: [{ type: "text", text: readFileSync17(path27.resolve(file), "utf8") }] };
+  return { content: [{ type: "text", text: readFileSync18(path28.resolve(file), "utf8") }] };
 }
 async function runRecordIngest(opts) {
   let payload;
   try {
-    payload = opts.rawParts === true || opts.raw === true ? rawEnvelopeFromFile(opts.file, opts.rawParts === true) : JSON.parse(readFileSync17(path27.resolve(opts.file), "utf8"));
+    payload = opts.rawParts === true || opts.raw === true ? rawEnvelopeFromFile(opts.file, opts.rawParts === true) : JSON.parse(readFileSync18(path28.resolve(opts.file), "utf8"));
   } catch (err) {
     fail(opts, ExitCode.InputValidation, {
       error: `cannot read envelope file: ${err instanceof Error ? err.message : String(err)}`,
@@ -8363,7 +8782,7 @@ async function runRecordIngest(opts) {
     fail(opts, ExitCode.InputValidation, {
       error: "--raw is for text tool responses; screenshots are binary",
       code: "envelope-invalid",
-      remediation: `Use \`${tendrilCommand(`record fetch --set ${path27.resolve(opts.setDir)} --rep ${opts.rep} --tool ${opts.tool} --url <image_url>`)}\` instead.`
+      remediation: `Use \`${tendrilCommand(`record fetch --set ${path28.resolve(opts.setDir)} --rep ${opts.rep} --tool ${opts.tool} --url <image_url>`)}\` instead.`
     });
   }
   if (opts.rep === "__set__" && opts.tool === "get_variable_defs") {
@@ -8383,7 +8802,7 @@ async function runRecordIngest(opts) {
         remediation: REINGEST_GUIDANCE
       });
     }
-    writeFileSync9(path27.join(opts.setDir, "get_variable_defs.json"), `${JSON.stringify(payload, null, 1)}
+    writeFileSync9(path28.join(opts.setDir, "get_variable_defs.json"), `${JSON.stringify(payload, null, 1)}
 `);
     emitData(opts, { ingested: "get_variable_defs", rep: "__set__", setLevel: true, next: nextPayload(opts.setDir) }, () => {
       process.stdout.write("set-level get_variable_defs ingested\n");
@@ -8399,7 +8818,7 @@ async function runRecordIngest(opts) {
       if (assets !== void 0) {
         for (const a of assets.fetched) process.stdout.write(`  asset fetched ${a}
 `);
-        for (const f of assets.failed) process.stdout.write(`  ASSET FAILED ${f.name}: ${f.reason} \u2014 download it, then: ${tendrilCommand(`record asset --set ${path27.resolve(opts.setDir)} --rep ${opts.rep} --name ${f.name} --file <downloaded-file>`)}
+        for (const f of assets.failed) process.stdout.write(`  ASSET FAILED ${f.name}: ${f.reason} \u2014 download it, then: ${tendrilCommand(`record asset --set ${path28.resolve(opts.setDir)} --rep ${opts.rep} --name ${f.name} --file <downloaded-file>`)}
 `);
       }
     });
@@ -8472,15 +8891,15 @@ async function runRecordIngestRep(opts) {
     if (assets !== void 0) {
       for (const a of assets.fetched) process.stdout.write(`  asset fetched ${a}
 `);
-      for (const f of assets.failed) process.stdout.write(`  ASSET FAILED ${f.name}: ${f.reason} \u2014 download it, then: ${tendrilCommand(`record asset --set ${path27.resolve(opts.setDir)} --rep ${opts.rep} --name ${f.name} --file <downloaded-file>`)}
+      for (const f of assets.failed) process.stdout.write(`  ASSET FAILED ${f.name}: ${f.reason} \u2014 download it, then: ${tendrilCommand(`record asset --set ${path28.resolve(opts.setDir)} --rep ${opts.rep} --name ${f.name} --file <downloaded-file>`)}
 `);
     }
   });
 }
 function runRecordAsset(opts) {
   if (opts.dir !== void 0) {
-    const dir = path27.resolve(opts.dir);
-    const names = readdirSync6(dir).filter((f) => /^asset-[\w.-]+\.(svg|png|jpe?g|webp|gif)$/i.test(f));
+    const dir = path28.resolve(opts.dir);
+    const names = readdirSync8(dir).filter((f) => /^asset-[\w.-]+\.(svg|png|jpe?g|webp|gif)$/i.test(f));
     if (names.length === 0) {
       fail(opts, ExitCode.InputValidation, {
         error: `no asset-*.<ext> files found in ${dir}`,
@@ -8491,7 +8910,7 @@ function runRecordAsset(opts) {
     const ingested = [];
     try {
       for (const name of names) {
-        ingestAsset(opts.setDir, opts.rep, name, readFileSync17(path27.join(dir, name)));
+        ingestAsset(opts.setDir, opts.rep, name, readFileSync18(path28.join(dir, name)));
         ingested.push(name);
       }
     } catch (err) {
@@ -8511,11 +8930,11 @@ function runRecordAsset(opts) {
     fail(opts, ExitCode.InputValidation, {
       error: "pass --name and --file for a single asset, or --dir for a batch",
       code: "asset-rejected",
-      remediation: tendrilCommand(`record asset --set ${path27.resolve(opts.setDir)} --rep ${opts.rep} --dir <downloads-dir>`)
+      remediation: tendrilCommand(`record asset --set ${path28.resolve(opts.setDir)} --rep ${opts.rep} --dir <downloads-dir>`)
     });
   }
   try {
-    ingestAsset(opts.setDir, opts.rep, opts.name, readFileSync17(path27.resolve(opts.file)));
+    ingestAsset(opts.setDir, opts.rep, opts.name, readFileSync18(path28.resolve(opts.file)));
     emitData(opts, { rep: opts.rep, asset: opts.name }, () => {
       process.stdout.write(`ingested ${opts.rep}/${opts.name}
 `);
@@ -8562,7 +8981,7 @@ function narrowedRoles(derived, override) {
 function rolesFromFile(opts, file, derived) {
   let json;
   try {
-    json = JSON.parse(readFileSync17(path27.resolve(file), "utf8"));
+    json = JSON.parse(readFileSync18(path28.resolve(file), "utf8"));
   } catch (err) {
     fail(opts, ExitCode.InputValidation, {
       error: `cannot read roles file ${file}: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`,
@@ -8600,11 +9019,11 @@ function rolesFromFile(opts, file, derived) {
   };
 }
 function runRecordFinish(opts) {
-  if (!existsSync21(path27.join(opts.setDir, "recording-set.json"))) {
+  if (!existsSync22(path28.join(opts.setDir, "recording-set.json"))) {
     fail(opts, ExitCode.InputValidation, {
       error: `no recording-set.json in ${opts.setDir}`,
       code: "no-recording-set",
-      remediation: `Run \`${tendrilCommand(`record plan --set ${path27.resolve(opts.setDir)} --component <name> --metadata <envelope.json>`)}\` first \u2014 \`record finish\` closes a set the planner opened.`
+      remediation: `Run \`${tendrilCommand(`record plan --set ${path28.resolve(opts.setDir)} --component <name> --metadata <envelope.json>`)}\` first \u2014 \`record finish\` closes a set the planner opened.`
     });
   }
   const { manifest, raw } = readManifestFile(opts.setDir);
@@ -8632,17 +9051,17 @@ function runRecordFinish(opts) {
     fail(opts, ExitCode.ConfirmationRequired, {
       error: "--confirm-roles (and --roles-file) require an interactive terminal \u2014 this confirmation is human-only",
       code: "roles-confirmation-not-interactive",
-      remediation: `A human runs \`${tendrilCommand(`record finish --set ${path27.resolve(opts.setDir)} --confirm-roles`)}\` in their own terminal. Agents: show the proposal to your operator instead of confirming it.`
+      remediation: `A human runs \`${tendrilCommand(`record finish --set ${path28.resolve(opts.setDir)} --confirm-roles`)}\` in their own terminal. Agents: show the proposal to your operator instead of confirming it.`
     });
   }
   const merged = { ...raw, roles };
-  const { issues } = validateRecordingSet(merged, (rel) => existsSync21(path27.join(opts.setDir, rel)));
+  const { issues } = validateRecordingSet(merged, (rel) => existsSync22(path28.join(opts.setDir, rel)));
   const errors = issues.filter((i) => i.severity === "error");
   if (errors.length > 0) {
     fail(opts, ExitCode.InputValidation, {
       error: `recording set rejected \u2014 roles NOT written: ${errors.map((e) => e.message).join("; ")}`,
       code: "recording-set-invalid",
-      remediation: `Fix the set (\`${tendrilCommand(`record status --set ${path27.resolve(opts.setDir)}`)}\` lists missing envelopes) or the roles graph, then re-run \`record finish\`.`
+      remediation: `Fix the set (\`${tendrilCommand(`record status --set ${path28.resolve(opts.setDir)}`)}\` lists missing envelopes) or the roles graph, then re-run \`record finish\`.`
     });
   }
   for (const issue of issues) if (issue.severity === "warning") warn(opts, issue.message);
@@ -8876,9 +9295,9 @@ var init_engine_curated = __esm({
 });
 
 // packages/generate/src/loop.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync6, readFileSync as readFileSync18, renameSync, writeFileSync as writeFileSync10 } from "node:fs";
-import path28 from "node:path";
-import { z as z11 } from "zod";
+import { existsSync as existsSync23, mkdirSync as mkdirSync6, readFileSync as readFileSync19, renameSync, writeFileSync as writeFileSync10 } from "node:fs";
+import path29 from "node:path";
+import { z as z12 } from "zod";
 function objective(scores, behaviors) {
   const vals = scores.map((s) => Math.min(s.similarity, s.inkRecall));
   return [
@@ -8914,9 +9333,9 @@ ${absentLines.join("\n")}` : ""}
 Fix the FAIL configs (region coordinates are in the recorded screenshot's frame; ink<1 means recorded foreground pixels your render does not cover). Reading the pair: ink credits a recorded pixel when ANY render ink lands within 1px of it, so ink=1 proves coverage \u2014 not presence, shape, or colour. A wrong-shaped mark over the right region, or a wrong-coloured one that is still ink, scores 1.000; and a recorded mark within ~30 channel-sum of the backdrop (#f6f6f6 on white is 27) is not ink at all, so it can be absent at ink 1.000 with no MISSING line. With ink=1 AND low sim, coverage held while pixels differ, so start with the TWO causes below \u2014 but never read ink=1 as "nothing is missing": confirm every faint or small recorded mark (hairlines, dividers, low-contrast controls) exists in your render. GEOMETRY: wrong position/size/radius; the diff shows shifted edges and bands. WRONG TEXT WEIGHT OR FACE: the diff shows a uniform haze over glyph runs; CSS binds the font FAMILY before the weight, a later family in the stack is never consulted for a weight the first one lacks, and font-synthesis: none rules out faux-bold \u2014 so a stack led by a family the kit holds at one weight renders every other weight in that face, silently. Check the font stack against the kit's cached faces before concluding geometry is at fault. LOW ink with high sim means recorded marks are absent or painted invisibly. Do not regress PASS configs. ${mode === "files" ? "Update the files in your candidate directory and re-run the score." : "Reply with the complete corrected files in the same FILE format."}`;
 }
 function archivePriorRun(outDir) {
-  if (!existsSync22(path28.join(outDir, "run-log.json")) && !existsSync22(path28.join(outDir, "loop-state.json"))) return void 0;
+  if (!existsSync23(path29.join(outDir, "run-log.json")) && !existsSync23(path29.join(outDir, "loop-state.json"))) return void 0;
   let n = 1;
-  while (existsSync22(`${outDir}-prev-${n}`)) n += 1;
+  while (existsSync23(`${outDir}-prev-${n}`)) n += 1;
   renameSync(outDir, `${outDir}-prev-${n}`);
   return `${outDir}-prev-${n}`;
 }
@@ -8925,14 +9344,14 @@ async function runEngineLoop(opts) {
   const plateau = opts.plateau ?? 2;
   const progress = opts.onProgress ?? (() => {
   });
-  const statePath = path28.join(opts.outDir, "loop-state.json");
-  const resuming = opts.resume === true && existsSync22(statePath);
+  const statePath = path29.join(opts.outDir, "loop-state.json");
+  const resuming = opts.resume === true && existsSync23(statePath);
   if (!resuming) {
     const archived = archivePriorRun(opts.outDir);
     if (archived !== void 0) progress(`previous run archived to ${archived}`);
   }
   mkdirSync6(opts.outDir, { recursive: true });
-  const scratch = path28.join(opts.outDir, ".candidate");
+  const scratch = path29.join(opts.outDir, ".candidate");
   let attempts = [];
   let log = [];
   let best;
@@ -8940,7 +9359,7 @@ async function runEngineLoop(opts) {
   let nonAccepted = 0;
   let stopReason = "max-iterations";
   if (resuming) {
-    const restored = LoopStateSchema.parse(JSON.parse(readFileSync18(statePath, "utf8")));
+    const restored = LoopStateSchema.parse(JSON.parse(readFileSync19(statePath, "utf8")));
     attempts = restored.attempts;
     log = restored.iterations;
     spentUsd = restored.spentUsd;
@@ -8960,7 +9379,7 @@ async function runEngineLoop(opts) {
   };
   const writeCandidate = (files) => {
     mkdirSync6(scratch, { recursive: true });
-    for (const [name, content] of Object.entries(files)) writeFileSync10(path28.join(scratch, name), content);
+    for (const [name, content] of Object.entries(files)) writeFileSync10(path29.join(scratch, name), content);
   };
   const scoreCandidate = async (candidate, iter, usd, modelMs) => {
     writeCandidate(candidate.files);
@@ -9018,8 +9437,8 @@ async function runEngineLoop(opts) {
       const usd = candidate.usage?.usd ?? 0;
       spentUsd += usd;
       if (candidate.raw !== void 0) {
-        mkdirSync6(path28.join(opts.outDir, "responses"), { recursive: true });
-        writeFileSync10(path28.join(opts.outDir, "responses", `iter-${iter}.md`), candidate.raw);
+        mkdirSync6(path29.join(opts.outDir, "responses"), { recursive: true });
+        writeFileSync10(path29.join(opts.outDir, "responses", `iter-${iter}.md`), candidate.raw);
       }
       if (candidate.files[opts.entry] === void 0 || candidate.files["styles.css"] === void 0) {
         const finish = candidate.usage?.finishReason ?? "?";
@@ -9045,10 +9464,10 @@ async function runEngineLoop(opts) {
       }
     }
   }
-  if (best !== void 0) for (const [name, content] of Object.entries(best.files)) writeFileSync10(path28.join(opts.outDir, name), content);
+  if (best !== void 0) for (const [name, content] of Object.entries(best.files)) writeFileSync10(path29.join(opts.outDir, name), content);
   const final = best !== void 0 ? await opts.score(opts.outDir) : { scores: [], behaviors: [] };
   writeFileSync10(
-    path28.join(opts.outDir, "run-log.json"),
+    path29.join(opts.outDir, "run-log.json"),
     `${JSON.stringify(
       {
         ...opts.meta,
@@ -9072,42 +9491,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 = z11.object({ x0: z11.number(), y0: z11.number(), x1: z11.number(), y1: z11.number(), density: z11.number() });
-    ConfigScoreSchema = z11.object({
-      rep: z11.string(),
-      similarity: z11.number(),
-      inkRecall: z11.number(),
-      pass: z11.boolean(),
-      error: z11.string().optional(),
+    RegionSchema = z12.object({ x0: z12.number(), y0: z12.number(), x1: z12.number(), y1: z12.number(), density: z12.number() });
+    ConfigScoreSchema = z12.object({
+      rep: z12.string(),
+      similarity: z12.number(),
+      inkRecall: z12.number(),
+      pass: z12.boolean(),
+      error: z12.string().optional(),
       region: RegionSchema.optional()
     });
-    BehaviorResultSchema = z11.object({ id: z11.string(), pass: z11.boolean(), detail: z11.string().optional() });
-    LoopStateSchema = z11.object({
-      version: z11.literal(1),
-      spentUsd: z11.number(),
-      attempts: z11.array(
-        z11.object({
-          candidate: z11.object({
-            files: z11.record(z11.string(), z11.string()),
-            raw: z11.string().optional(),
-            usage: z11.object({ usd: z11.number(), inTokens: z11.number(), outTokens: z11.number(), modelMs: z11.number(), finishReason: z11.string().optional() }).optional()
+    BehaviorResultSchema = z12.object({ id: z12.string(), pass: z12.boolean(), detail: z12.string().optional() });
+    LoopStateSchema = z12.object({
+      version: z12.literal(1),
+      spentUsd: z12.number(),
+      attempts: z12.array(
+        z12.object({
+          candidate: z12.object({
+            files: z12.record(z12.string(), z12.string()),
+            raw: z12.string().optional(),
+            usage: z12.object({ usd: z12.number(), inTokens: z12.number(), outTokens: z12.number(), modelMs: z12.number(), finishReason: z12.string().optional() }).optional()
           }),
-          rulerScore: z11.object({ passCount: z11.number(), floor: z11.number(), mean: z11.number() }),
-          accepted: z11.boolean(),
-          feedback: z11.string()
+          rulerScore: z12.object({ passCount: z12.number(), floor: z12.number(), mean: z12.number() }),
+          accepted: z12.boolean(),
+          feedback: z12.string()
         })
       ),
-      iterations: z11.array(
-        z11.object({
-          iter: z11.number(),
-          usd: z11.number(),
-          modelMs: z11.number().optional(),
-          scoreMs: z11.number().optional(),
-          objective: z11.tuple([z11.number(), z11.number(), z11.number()]),
-          accepted: z11.boolean(),
-          scores: z11.array(ConfigScoreSchema),
-          behaviors: z11.array(BehaviorResultSchema).optional(),
-          parseError: z11.string().optional()
+      iterations: z12.array(
+        z12.object({
+          iter: z12.number(),
+          usd: z12.number(),
+          modelMs: z12.number().optional(),
+          scoreMs: z12.number().optional(),
+          objective: z12.tuple([z12.number(), z12.number(), z12.number()]),
+          accepted: z12.boolean(),
+          scores: z12.array(ConfigScoreSchema),
+          behaviors: z12.array(BehaviorResultSchema).optional(),
+          parseError: z12.string().optional()
         })
       )
     });
@@ -9115,8 +9534,8 @@ var init_loop2 = __esm({
 });
 
 // packages/generate/src/brief.ts
-import { existsSync as existsSync23, readFileSync as readFileSync19 } from "node:fs";
-import path29 from "node:path";
+import { existsSync as existsSync24, readFileSync as readFileSync20 } from "node:fs";
+import path30 from "node:path";
 function singleAxes2(name) {
   const parsed = parseVariantAxes(name);
   if (parsed === void 0) return void 0;
@@ -9357,21 +9776,21 @@ function authorBehaviors(api, extras = {}) {
   return { behaviors, prelude: { controls: interactive ? ["> *"] : [], textInputs: [] }, disclosures };
 }
 function envelopeText(file) {
-  return envelopeFirstTextPart(JSON.parse(readFileSync19(file, "utf8")));
+  return envelopeFirstTextPart(JSON.parse(readFileSync20(file, "utf8")));
 }
 function metadataText(file) {
-  return envelopeTextContent(JSON.parse(readFileSync19(file, "utf8")));
+  return envelopeTextContent(JSON.parse(readFileSync20(file, "utf8")));
 }
 function dismissEvidence(setDir, repSlugs) {
   for (const slug of repSlugs) {
-    const f = path29.join(setDir, slug, "get_design_context.json");
-    if (!existsSync23(f)) continue;
+    const f = path30.join(setDir, slug, "get_design_context.json");
+    if (!existsSync24(f)) continue;
     const text = envelopeText(f);
     const propHit = /[{,]\s*(\w*dismiss\w*)\s*=\s*(?:true|false)\b/i.exec(text) ?? /\b(\w*dismiss\w*)\??\s*:\s*boolean\b/i.exec(text);
     if (propHit !== null) return `emission prop "${propHit[1]}"`;
     for (const m of text.matchAll(/data-name="([^"]+)"/g)) {
-      const norm = m[1].toLowerCase().replace(/[^a-z0-9]/g, "");
-      if (DISMISS_NAMES.has(norm)) return `layer ${JSON.stringify(m[1])}`;
+      const norm2 = m[1].toLowerCase().replace(/[^a-z0-9]/g, "");
+      if (DISMISS_NAMES.has(norm2)) return `layer ${JSON.stringify(m[1])}`;
     }
   }
   return void 0;
@@ -9409,13 +9828,13 @@ function recordedFontNeeds(setDir, opts = {}) {
     }
   };
   const manifest = loadManifest(setDir);
-  const setDefs = path29.join(setDir, "get_variable_defs.json");
-  if (existsSync23(setDefs)) fromDefs(envelopeText(setDefs));
+  const setDefs = path30.join(setDir, "get_variable_defs.json");
+  if (existsSync24(setDefs)) fromDefs(envelopeText(setDefs));
   for (const rep of manifest.reps) {
-    const ctx = path29.join(setDir, rep.slug, "get_design_context.json");
-    if (existsSync23(ctx)) fromEmission(envelopeText(ctx));
-    const defs = path29.join(setDir, rep.slug, "get_variable_defs.json");
-    if (existsSync23(defs)) fromDefs(envelopeText(defs));
+    const ctx = path30.join(setDir, rep.slug, "get_design_context.json");
+    if (existsSync24(ctx)) fromEmission(envelopeText(ctx));
+    const defs = path30.join(setDir, rep.slug, "get_variable_defs.json");
+    if (existsSync24(defs)) fromDefs(envelopeText(defs));
   }
   return [...byFamily.entries()].map(([family, paired]) => {
     const weights = /* @__PURE__ */ new Set([...paired, ...opts.pairedOnly === true ? [] : unpaired]);
@@ -9426,10 +9845,10 @@ function symbolFontGlyphCount(setDir, reps) {
   const PUA = /[\uE000-\uF8FF\u{F0000}-\u{FFFFD}\u{100000}-\u{10FFFD}]/u;
   const glyphs = /* @__PURE__ */ new Set();
   for (const rep of reps) {
-    const file = path29.join(setDir, rep, "get_metadata.json");
-    if (!existsSync23(file)) continue;
+    const file = path30.join(setDir, rep, "get_metadata.json");
+    if (!existsSync24(file)) continue;
     try {
-      const text = JSON.parse(readFileSync19(file, "utf8")).content.map((c) => c.text ?? "").join("\n");
+      const text = JSON.parse(readFileSync20(file, "utf8")).content.map((c) => c.text ?? "").join("\n");
       for (const m of text.matchAll(/<text\s[^>]*name="([^"]*)"/g)) {
         const name = decodeXmlEntities(m[1]).replace(/&#x([0-9a-fA-F]+);/g, (_, h) => String.fromCodePoint(parseInt(h, 16))).replace(/&#(\d+);/g, (_, d) => String.fromCodePoint(Number(d)));
         if (PUA.test(name)) glyphs.add(name);
@@ -9455,8 +9874,8 @@ function recordedTextSlots(setDir, repSlugs) {
   const propRep = [];
   const perRep = [];
   for (const slug of repSlugs) {
-    const f = path29.join(setDir, slug, "get_design_context.json");
-    if (!existsSync23(f)) continue;
+    const f = path30.join(setDir, slug, "get_design_context.json");
+    if (!existsSync24(f)) continue;
     const code = envelopeText(f);
     const props = /* @__PURE__ */ new Map();
     for (const m of code.matchAll(/[{,]\s*(\w+)\s*=\s*"((?:[^"\\]|\\.)*)"/g)) {
@@ -9481,8 +9900,8 @@ function recordedTextSlots(setDir, repSlugs) {
   }
   const axisValuesBySlug = /* @__PURE__ */ new Map();
   for (const slug of repSlugs) {
-    const metaFile = path29.join(setDir, slug, "get_metadata.json");
-    if (!existsSync23(metaFile)) continue;
+    const metaFile = path30.join(setDir, slug, "get_metadata.json");
+    if (!existsSync24(metaFile)) continue;
     const name = symbolName(metadataText(metaFile));
     if (name === void 0) continue;
     const values = /* @__PURE__ */ new Set();
@@ -9581,8 +10000,8 @@ function authorTaskFromSet(setDir, opts = {}) {
   const poses = [];
   const missing = [];
   for (const rep of manifest.reps) {
-    const metaFile = path29.join(setDir, rep.slug, "get_metadata.json");
-    if (!existsSync23(metaFile)) {
+    const metaFile = path30.join(setDir, rep.slug, "get_metadata.json");
+    if (!existsSync24(metaFile)) {
       missing.push(rep.slug);
       continue;
     }
@@ -9596,8 +10015,8 @@ function authorTaskFromSet(setDir, opts = {}) {
   if (missing.length > 0) {
     throw new Error(`recording set ${setDir} is missing metadata for ${missing.length} rep(s): ${missing.slice(0, 5).join(", ")}${missing.length > 5 ? ", \u2026" : ""}`);
   }
-  const setMeta = path29.join(setDir, "get_metadata.json");
-  const latticeNames = manifest.latticeNames ?? (existsSync23(setMeta) ? [...metadataText(setMeta).matchAll(/name="([^"]*)"/g)].map((m) => decodeXmlEntities(m[1])) : void 0);
+  const setMeta = path30.join(setDir, "get_metadata.json");
+  const latticeNames = manifest.latticeNames ?? (existsSync24(setMeta) ? [...metadataText(setMeta).matchAll(/name="([^"]*)"/g)].map((m) => decodeXmlEntities(m[1])) : void 0);
   const defaults = { ...manifest.defaults ?? {}, ...opts.defaults ?? {} };
   const recordedFonts = recordedFontFamilies(setDir);
   const textSlots = recordedTextSlots(setDir, manifest.reps.map((r) => r.slug));
@@ -9780,10 +10199,10 @@ var init_brief = __esm({
 });
 
 // packages/generate/src/segments.ts
-import { existsSync as existsSync24, readFileSync as readFileSync20, readdirSync as readdirSync7 } from "node:fs";
-import path30 from "node:path";
+import { existsSync as existsSync25, readFileSync as readFileSync21, readdirSync as readdirSync9 } from "node:fs";
+import path31 from "node:path";
 function repText(set, rep, tool) {
-  const env = JSON.parse(readFileSync20(path30.join(set, rep, `${tool}.json`), "utf8"));
+  const env = JSON.parse(readFileSync21(path31.join(set, rep, `${tool}.json`), "utf8"));
   return tool === "get_design_context" ? envelopeFirstTextPart(env) : envelopeTextContent(env);
 }
 function stripFigmaInstructions(emission) {
@@ -9843,20 +10262,20 @@ DROPPED from the map, untrustworthy in the source export \u2014 for these, each
 }
 function buildSegments(task, mode = "fenced") {
   const SET = task.set;
-  let defsRecorded = existsSync24(path30.join(SET, "get_variable_defs.json"));
+  let defsRecorded = existsSync25(path31.join(SET, "get_variable_defs.json"));
   let rawDefs = {};
-  if (existsSync24(path30.join(SET, "get_variable_defs.json"))) {
-    const text = envelopeFirstTextPart(JSON.parse(readFileSync20(path30.join(SET, "get_variable_defs.json"), "utf8"))) || "{}";
+  if (existsSync25(path31.join(SET, "get_variable_defs.json"))) {
+    const text = envelopeFirstTextPart(JSON.parse(readFileSync21(path31.join(SET, "get_variable_defs.json"), "utf8"))) || "{}";
     try {
       rawDefs = JSON.parse(text);
     } catch {
     }
   } else {
     for (const cfg of task.configs) {
-      const f = path30.join(SET, cfg.rep, "get_variable_defs.json");
-      if (!existsSync24(f)) continue;
+      const f = path31.join(SET, cfg.rep, "get_variable_defs.json");
+      if (!existsSync25(f)) continue;
       defsRecorded = true;
-      const text = envelopeFirstTextPart(JSON.parse(readFileSync20(f, "utf8"))) || "{}";
+      const text = envelopeFirstTextPart(JSON.parse(readFileSync21(f, "utf8"))) || "{}";
       try {
         for (const [k, v] of Object.entries(JSON.parse(text))) rawDefs[k] ??= v;
       } catch {
@@ -9864,8 +10283,8 @@ function buildSegments(task, mode = "fenced") {
     }
   }
   const emissionTexts = task.configs.map((cfg) => {
-    const f = path30.join(SET, cfg.rep, "get_design_context.json");
-    return existsSync24(f) ? envelopeFirstTextPart(JSON.parse(readFileSync20(f, "utf8"))) : "";
+    const f = path31.join(SET, cfg.rep, "get_design_context.json");
+    return existsSync25(f) ? envelopeFirstTextPart(JSON.parse(readFileSync21(f, "utf8"))) : "";
   });
   const { map, note } = cleanTokenMap(rawDefs, emissionTexts);
   const defs = JSON.stringify(map, null, 1);
@@ -9882,9 +10301,9 @@ TOKEN MAP NEVER RECORDED: this set holds no get_variable_defs envelope, so wheth
   for (const cfg of task.configs) {
     const meta = stripFigmaInstructions(repText(SET, cfg.rep, "get_metadata"));
     const emission = stripFigmaInstructions(repText(SET, cfg.rep, "get_design_context"));
-    const assets = readdirSync7(path30.join(SET, cfg.rep)).filter((f) => f.startsWith("asset-") && f.endsWith(".svg")).map((f) => `asset ${f}:
+    const assets = readdirSync9(path31.join(SET, cfg.rep)).filter((f) => f.startsWith("asset-") && f.endsWith(".svg")).map((f) => `asset ${f}:
 \`\`\`svg
-${readFileSync20(path30.join(SET, cfg.rep, f), "utf8")}
+${readFileSync21(path31.join(SET, cfg.rep, f), "utf8")}
 \`\`\``).join("\n");
     parts.push(`
 ## Config ${cfg.rep} \u2192 ${cfg.component} ${JSON.stringify(cfg.props)}
@@ -9909,7 +10328,7 @@ Optionally a third block with \`/* FILE: tokens.css */\`.`);
   } else {
     parts.push(`
 ## Output format
-Write the COMPLETE files (${task.entry}, styles.css, optional tokens.css) into ONE candidate directory: \`tendril-out/${path30.basename(task.set)}-candidate/\` unless you were handed another path. Pass that same directory to \`tendril engine score\` every round and keep writing into it \u2014 the scorer stamps the bundle there, writes its evidence beside your files, and appends its score-history.jsonl lines there (one when a round starts, one when it scores); a fresh directory each round throws all of that away. Do not paste file contents into chat \u2014 the scorer reads the directory.`);
+Write the COMPLETE files (${task.entry}, styles.css, optional tokens.css) into ONE candidate directory: \`tendril-out/${path31.basename(task.set)}-candidate/\` unless you were handed another path. Pass that same directory to \`tendril engine score\` every round and keep writing into it \u2014 the scorer stamps the bundle there, writes its evidence beside your files, and appends its score-history.jsonl lines there (one when a round starts, one when it scores); a fresh directory each round throws all of that away. Do not paste file contents into chat \u2014 the scorer reads the directory.`);
   }
   return parts.join("\n");
 }
@@ -9976,9 +10395,9 @@ var init_adapter = __esm({
 });
 
 // packages/generate/src/bundle-emit.ts
-import { createHash as createHash4 } from "node:crypto";
-import { copyFileSync, existsSync as existsSync25, mkdirSync as mkdirSync7, readFileSync as readFileSync21, readdirSync as readdirSync8, rmSync as rmSync3, writeFileSync as writeFileSync11 } from "node:fs";
-import path31 from "node:path";
+import { createHash as createHash5 } from "node:crypto";
+import { copyFileSync, existsSync as existsSync26, mkdirSync as mkdirSync7, readFileSync as readFileSync22, readdirSync as readdirSync10, rmSync as rmSync3, writeFileSync as writeFileSync11 } from "node:fs";
+import path32 from "node:path";
 function pinFromConfigs(configs) {
   const domains = /* @__PURE__ */ new Map();
   const kinds = /* @__PURE__ */ new Map();
@@ -10047,9 +10466,9 @@ function fontsCssFor(faces, bundleDir, cacheDir = DEFAULT_FONT_CACHE, substitute
   const notices = [];
   const licenseTexts = /* @__PURE__ */ new Map();
   for (const face of faces) {
-    const src = path31.join(cacheDir, path31.basename(face.file));
-    const target = `./fonts/${path31.basename(face.file)}`;
-    const format = FONT_FORMATS[path31.extname(face.file).toLowerCase()] ?? "truetype";
+    const src = path32.join(cacheDir, path32.basename(face.file));
+    const target = `./fonts/${path32.basename(face.file)}`;
+    const format = FONT_FORMATS[path32.extname(face.file).toLowerCase()] ?? "truetype";
     const family = face.family.replace(/['\\]/g, "").replace(/\*\//g, "");
     const decl = `@font-face { font-family: '${family}'; font-weight: ${face.weight}; font-style: normal; src: url(${target}) format('${format}'); }`;
     const license = normalizeFontLicense(face.license);
@@ -10087,14 +10506,14 @@ function fontsCssFor(faces, bundleDir, cacheDir = DEFAULT_FONT_CACHE, substitute
           `/* ${decl} */`
         );
       }
-    } else if (existsSync25(src) && createHash4("sha256").update(readFileSync21(src)).digest("hex") === face.sha256) {
-      mkdirSync7(path31.join(bundleDir, "fonts"), { recursive: true });
-      copyFileSync(src, path31.join(bundleDir, "fonts", path31.basename(face.file)));
+    } else if (existsSync26(src) && createHash5("sha256").update(readFileSync22(src)).digest("hex") === face.sha256) {
+      mkdirSync7(path32.join(bundleDir, "fonts"), { recursive: true });
+      copyFileSync(src, path32.join(bundleDir, "fonts", path32.basename(face.file)));
       licenseTexts.set(terms.file, terms.text);
       const upstream = upstreamAttribution(face);
       notices.push(
         "",
-        `${face.family.replace(/[\r\n]+/g, " ")} ${face.weight} \u2014 ./${path31.basename(face.file)}`,
+        `${face.family.replace(/[\r\n]+/g, " ")} ${face.weight} \u2014 ./${path32.basename(face.file)}`,
         `  licence:   ${terms.title} \u2014 full text in ./${terms.file}`,
         `  source:    ${face.source}`,
         `  sha256:    ${face.sha256}`,
@@ -10108,9 +10527,9 @@ function fontsCssFor(faces, bundleDir, cacheDir = DEFAULT_FONT_CACHE, substitute
   }
   if (lines.length === 0) return null;
   if (notices.length > 0) {
-    const fontsDir = path31.join(bundleDir, "fonts");
-    for (const [file, text] of licenseTexts) writeFileSync11(path31.join(fontsDir, file), text);
-    writeFileSync11(path31.join(fontsDir, "NOTICE.txt"), `${[NOTICE_PREAMBLE, ...notices].join("\n")}
+    const fontsDir = path32.join(bundleDir, "fonts");
+    for (const [file, text] of licenseTexts) writeFileSync11(path32.join(fontsDir, file), text);
+    writeFileSync11(path32.join(fontsDir, "NOTICE.txt"), `${[NOTICE_PREAMBLE, ...notices].join("\n")}
 `);
     header.push(
       "/* REDISTRIBUTION: the face files in ./fonts/ are redistributed under the licences",
@@ -10122,10 +10541,10 @@ function fontsCssFor(faces, bundleDir, cacheDir = DEFAULT_FONT_CACHE, substitute
 `;
 }
 function countLatticeSymbols(setDir) {
-  const manifestFile = path31.join(setDir, "recording-set.json");
-  if (existsSync25(manifestFile)) {
+  const manifestFile = path32.join(setDir, "recording-set.json");
+  if (existsSync26(manifestFile)) {
     try {
-      const stored = JSON.parse(readFileSync21(manifestFile, "utf8"));
+      const stored = JSON.parse(readFileSync22(manifestFile, "utf8"));
       if (stored.variantScope !== "component-set") return null;
       const lattice = stored.latticeNames;
       if (lattice !== void 0 && lattice.length > 0) return lattice.length;
@@ -10133,13 +10552,13 @@ function countLatticeSymbols(setDir) {
     }
   }
   const files = [
-    path31.join(setDir, "get_metadata.json"),
-    ...existsSync25(setDir) ? readdirSync8(setDir).filter((f) => /^get_metadata-.*\.json$/.test(f)).map((f) => path31.join(setDir, f)) : []
-  ].filter((f) => existsSync25(f));
+    path32.join(setDir, "get_metadata.json"),
+    ...existsSync26(setDir) ? readdirSync10(setDir).filter((f) => /^get_metadata-.*\.json$/.test(f)).map((f) => path32.join(setDir, f)) : []
+  ].filter((f) => existsSync26(f));
   if (files.length === 0) return null;
   let count = 0;
   for (const f of files) {
-    const text = envelopeTextContent(JSON.parse(readFileSync21(f, "utf8")));
+    const text = envelopeTextContent(JSON.parse(readFileSync22(f, "utf8")));
     count += [...text.matchAll(/name="([^"]*)"/g)].filter((m) => m[1].includes("=")).length;
   }
   return count > 0 ? count : null;
@@ -10147,23 +10566,23 @@ function countLatticeSymbols(setDir) {
 function recordingSetHash(setDir, configs) {
   const relPaths = [];
   for (const name of ["recording-set.json", "completeness-manifest.json", "get_variable_defs.json", "get_metadata.json"]) {
-    if (existsSync25(path31.join(setDir, name))) relPaths.push(name);
+    if (existsSync26(path32.join(setDir, name))) relPaths.push(name);
   }
   for (const cfg of configs) {
     for (const f of ["get_design_context.json", "get_metadata.json", "get_screenshot.json", "get_variable_defs.json"]) {
-      if (existsSync25(path31.join(setDir, cfg.rep, f))) relPaths.push(`${cfg.rep}/${f}`);
+      if (existsSync26(path32.join(setDir, cfg.rep, f))) relPaths.push(`${cfg.rep}/${f}`);
     }
-    if (existsSync25(path31.join(setDir, cfg.rep))) {
-      for (const asset of readdirSync8(path31.join(setDir, cfg.rep)).filter((f) => f.startsWith("asset-"))) {
+    if (existsSync26(path32.join(setDir, cfg.rep))) {
+      for (const asset of readdirSync10(path32.join(setDir, cfg.rep)).filter((f) => f.startsWith("asset-"))) {
         relPaths.push(`${cfg.rep}/${asset}`);
       }
     }
   }
   return hashRecordingSet(
     relPaths,
-    (p) => new Uint8Array(readFileSync21(path31.join(setDir, p))),
+    (p) => new Uint8Array(readFileSync22(path32.join(setDir, p))),
     (chunks) => {
-      const h = createHash4("sha256");
+      const h = createHash5("sha256");
       for (const c of chunks) h.update(c);
       return h.digest("hex");
     }
@@ -10182,11 +10601,11 @@ function emitBundleV1(opts) {
   const certified = statuses.filter((s) => s.status === "certified").length;
   const pass = statuses.filter((s) => s.status !== "fail").length;
   const lattice = countLatticeSymbols(opts.task.set);
-  const interaction = opts.behaviors.filter((b) => !b.id.startsWith("prelude:") && !b.id.startsWith("parity:"));
+  const interaction = opts.behaviors.filter((b) => !b.id.startsWith("prelude:") && !b.id.startsWith("parity:") && !b.id.startsWith("composition:"));
   const prelude = opts.behaviors.filter((b) => b.id.startsWith("prelude:"));
   const parity = opts.behaviors.filter((b) => b.id.startsWith("parity:"));
-  const cssFiles = ["styles.css", "tokens.css"].map((f) => path31.join(opts.bundleDir, f)).filter((f) => existsSync25(f));
-  const families = cssFontFamilies(cssFiles.map((f) => readFileSync21(f, "utf8")).join("\n"));
+  const cssFiles = ["styles.css", "tokens.css"].map((f) => path32.join(opts.bundleDir, f)).filter((f) => existsSync26(f));
+  const families = cssFontFamilies(cssFiles.map((f) => readFileSync22(f, "utf8")).join("\n"));
   const requiredFonts = requiredFontsManifest(families, opts.fontCacheDir).map((f) => ({
     family: f.family,
     weight: f.weight,
@@ -10215,7 +10634,7 @@ function emitBundleV1(opts) {
         // resolvable via verify's --set override).
         path: (() => {
           const base = process.env["INIT_CWD"] ?? process.cwd();
-          const rel = path31.relative(base, opts.task.set);
+          const rel = path32.relative(base, opts.task.set);
           return rel !== "" && !rel.startsWith("..") ? rel : opts.task.set;
         })(),
         component: opts.componentName,
@@ -10239,21 +10658,21 @@ function emitBundleV1(opts) {
     })
   };
   const written = [];
-  const manifestPath2 = path31.join(opts.bundleDir, "component.json");
+  const manifestPath2 = path32.join(opts.bundleDir, "component.json");
   writeFileSync11(manifestPath2, `${JSON.stringify(manifest, null, 2)}
 `);
   written.push(manifestPath2);
-  const stylesPath = path31.join(opts.bundleDir, "styles.css");
-  if (existsSync25(stylesPath)) {
+  const stylesPath = path32.join(opts.bundleDir, "styles.css");
+  if (existsSync26(stylesPath)) {
     const comment = cssProvenanceComment({ pass, scored: statuses.length, certified, latticeConfigs: lattice });
-    const current = readFileSync21(stylesPath, "utf8");
+    const current = readFileSync22(stylesPath, "utf8");
     const stripped = current.replace(/^\/\* tendril bundle v\d+ [^]*?\*\/\n/, "");
     writeFileSync11(stylesPath, `${comment}
 ${stripped}`);
     written.push(stylesPath);
   }
-  const fontsCssPath = path31.join(opts.bundleDir, "fonts.css");
-  rmSync3(path31.join(opts.bundleDir, "fonts"), { recursive: true, force: true });
+  const fontsCssPath = path32.join(opts.bundleDir, "fonts.css");
+  rmSync3(path32.join(opts.bundleDir, "fonts"), { recursive: true, force: true });
   rmSync3(fontsCssPath, { force: true });
   const fontsCss = fontsCssFor(requiredFontsManifest(families, opts.fontCacheDir), opts.bundleDir, opts.fontCacheDir, opts.substitutedFamilies ?? []);
   if (fontsCss !== null) {
@@ -10681,6 +11100,262 @@ DEALINGS IN THE FONT SOFTWARE.
   }
 });
 
+// packages/generate/src/compose-pins.ts
+import { createHash as createHash6 } from "node:crypto";
+import { existsSync as existsSync27, readFileSync as readFileSync23, readdirSync as readdirSync11, realpathSync as realpathSync3, statSync as statSync3 } from "node:fs";
+import path33 from "node:path";
+function bundleDirs(roots, depth = 4) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const walk2 = (dir, remaining) => {
+    let key;
+    try {
+      key = realpathSync3(dir);
+    } catch {
+      key = path33.resolve(dir);
+    }
+    if (seen.has(key)) return;
+    seen.add(key);
+    if (existsSync27(path33.join(dir, "component.json"))) {
+      found.push(key);
+      return;
+    }
+    if (remaining === 0) return;
+    let entries;
+    try {
+      entries = readdirSync11(dir);
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e === "node_modules" || e.startsWith(".")) continue;
+      const full = path33.join(dir, e);
+      try {
+        if (statSync3(full).isDirectory()) walk2(full, remaining - 1);
+      } catch {
+      }
+    }
+  };
+  for (const r of roots) walk2(path33.resolve(r), depth);
+  return found;
+}
+function composedPins(hostSet, libraryRoots) {
+  const { rows, malformed } = confirmedCompositionStatus(hostSet);
+  const issues = [];
+  if (malformed !== void 0) issues.push(`compositions extension partially unreadable (${malformed}) \u2014 the affected entries are not pinned`);
+  const usable = rows.filter((r) => r.status === "supported" || r.status === "stale-supported");
+  for (const r of rows) {
+    if (!usable.includes(r)) issues.push(`confirmed pair ${r.key} is ${r.status} \u2014 not pinned (${r.detail})`);
+  }
+  if (usable.length === 0) return { pins: [], issues };
+  const candidates = bundleDirs(libraryRoots);
+  const pins = [];
+  for (const row of usable) {
+    const partnerRels = row.key.split("+");
+    let pinned = false;
+    const failures = [];
+    for (const rel of partnerRels) {
+      const partnerSet = path33.resolve(hostSet, rel);
+      let partnerTask;
+      let partnerManifest;
+      try {
+        partnerManifest = loadManifest(partnerSet);
+        partnerTask = authorTaskFromSet(partnerSet).task;
+      } catch (err) {
+        failures.push(`${rel}: partner set does not author (${err instanceof Error ? err.message.split("\n")[0] : String(err)})`);
+        continue;
+      }
+      const slugByVariant = new Map(partnerManifest.reps.map((rep) => [rep.nodeId, rep.slug]));
+      const wantedPoses = /* @__PURE__ */ new Map();
+      let poseMissing = false;
+      for (const inst of row.instances) {
+        const slug = slugByVariant.get(inst.poseVariantNodeId);
+        const cfg = slug !== void 0 ? partnerTask.configs.find((c) => c.rep === slug) : void 0;
+        if (slug === void 0 || cfg === void 0) {
+          poseMissing = true;
+          break;
+        }
+        wantedPoses.set(inst.poseVariantNodeId, slug);
+      }
+      if (poseMissing) {
+        failures.push(`${rel}: does not record the confirmed pose`);
+        continue;
+      }
+      const wantHash = recordingSetHash(partnerSet, partnerTask.configs);
+      const matches = candidates.filter((dir) => {
+        try {
+          const parsed = readBundleManifest(readFileSync23(path33.join(dir, "component.json"), "utf8"));
+          return parsed.manifest?.provenance.recordingSet.hash === wantHash;
+        } catch {
+          return false;
+        }
+      });
+      if (matches.length === 0) {
+        failures.push(
+          `${rel}: no generated bundle joins this set's CURRENT recording hash (searched ${libraryRoots.length} root(s) to depth 4) \u2014 generate the partner first (a stale partner bundle does not join; regenerate it), or pass --library <dir> if the bundle lives elsewhere`
+        );
+        continue;
+      }
+      if (matches.length > 1) {
+        failures.push(`${rel}: ${matches.length} bundles join the same recording hash (${matches.map((m) => path33.basename(m)).join(", ")}) \u2014 ambiguous; remove or point --library away from the duplicates`);
+        continue;
+      }
+      const bundleDir = matches[0];
+      let manifest;
+      try {
+        manifest = readBundleManifest(readFileSync23(path33.join(bundleDir, "component.json"), "utf8")).manifest;
+      } catch {
+        manifest = void 0;
+      }
+      if (manifest === void 0) {
+        failures.push(`${rel}: partner bundle manifest at ${bundleDir} became unreadable`);
+        continue;
+      }
+      if (!safeSegment(manifest.name) || !safeSegment(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`
+        );
+        continue;
+      }
+      const moduleFiles = [];
+      let fileIssue;
+      for (const name of [manifest.entry, "styles.css", "tokens.css", "fonts.css"]) {
+        const file = path33.join(bundleDir, name);
+        if (!existsSync27(file)) {
+          if (name === manifest.entry || name === "styles.css") {
+            fileIssue = `${rel}: partner bundle is missing ${name}`;
+            break;
+          }
+          continue;
+        }
+        let bytes;
+        try {
+          bytes = readFileSync23(file);
+        } catch {
+          fileIssue = `${rel}: partner file ${name} at ${bundleDir} is unreadable`;
+          break;
+        }
+        if (bytes.byteLength > MAX_PINNED_FILE_BYTES) {
+          fileIssue = `${rel}: partner file ${name} exceeds the pin size cap (${bytes.byteLength} bytes)`;
+          break;
+        }
+        moduleFiles.push({ name, content: bytes.toString("utf8"), sha256: createHash6("sha256").update(bytes).digest("hex") });
+      }
+      if (fileIssue !== void 0) {
+        failures.push(fileIssue);
+        continue;
+      }
+      pins.push({
+        pairKey: row.key,
+        partnerName: manifest.name,
+        partnerBundleDir: bundleDir,
+        moduleFiles,
+        entryModule: manifest.entry,
+        entryComponent: manifest.entry.replace(/\.tsx?$/, ""),
+        instances: row.instances.map((inst) => {
+          const slug = slugByVariant.get(inst.poseVariantNodeId);
+          const cfg = partnerTask.configs.find((c) => c.rep === slug);
+          return { hostRep: inst.hostRep, instanceId: inst.instanceId, poseVariantNodeId: inst.poseVariantNodeId, partnerRep: slug, props: { ...cfg.props } };
+        })
+      });
+      pinned = true;
+      break;
+    }
+    if (!pinned) {
+      issues.push(`confirmed pair ${row.key} could not be pinned: ${failures.join("; ") || "no partner recording authored"}`);
+    }
+  }
+  const byDir = /* @__PURE__ */ new Map();
+  for (const pin of pins) {
+    const dir = composedModuleDir(pin.partnerName);
+    byDir.set(dir, [...byDir.get(dir) ?? [], pin]);
+  }
+  const conflicted = /* @__PURE__ */ new Set();
+  for (const [dir, group] of byDir) {
+    if (group.length < 2) continue;
+    const signature = (p) => p.moduleFiles.map((f) => `${f.name}:${f.sha256}`).sort().join(",");
+    if (new Set(group.map(signature)).size > 1) {
+      for (const p of group) conflicted.add(p);
+      issues.push(
+        `pairs ${group.map((p) => p.pairKey).join(" and ")} both prescribe ${dir}/ with DIFFERENT bytes \u2014 mutually unsatisfiable, none pinned; rename one partner component or point --library away from one of the bundles`
+      );
+    }
+  }
+  return { pins: pins.filter((p) => !conflicted.has(p)), issues };
+}
+function declaredImports(source) {
+  const stripped = source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+  const specs = [];
+  const patterns = [
+    /(?:^|[^.\w])import\s[^"'`;]*?from\s*["']([^"']+)["']/g,
+    /(?:^|[^.\w])export\s[^"'`;]*?from\s*["']([^"']+)["']/g,
+    /(?:^|[^.\w])import\s*\(\s*["']([^"']+)["']\s*\)/g,
+    /(?:^|[^.\w])require\s*\(\s*["']([^"']+)["']\s*\)/g
+  ];
+  for (const re of patterns) {
+    for (const m of stripped.matchAll(re)) specs.push(m[1]);
+  }
+  return specs;
+}
+function composedChecks(candidateDir, hostEntry, pins) {
+  const checks = [];
+  let entrySource = "";
+  try {
+    entrySource = readFileSync23(path33.join(candidateDir, hostEntry), "utf8");
+  } catch {
+  }
+  const candidateRoot = path33.resolve(candidateDir);
+  for (const pin of pins) {
+    const dir = composedModuleDir(pin.partnerName);
+    const resolvedDir = path33.resolve(candidateDir, dir);
+    if (!resolvedDir.startsWith(candidateRoot + path33.sep)) {
+      checks.push({ id: `composition:${pin.pairKey}:module-verbatim`, pass: false, detail: `pin path ${dir}/ escapes the candidate directory \u2014 refused` });
+      checks.push({ id: `composition:${pin.pairKey}:imported`, pass: false, detail: `pin path ${dir}/ escapes the candidate directory \u2014 refused` });
+      continue;
+    }
+    const wrong = [];
+    for (const f of pin.moduleFiles) {
+      if (!safeSegment(f.name)) {
+        wrong.push(`${f.name} refused (not a plain path segment)`);
+        continue;
+      }
+      const target = path33.join(candidateDir, dir, f.name);
+      if (!existsSync27(target)) {
+        wrong.push(`${f.name} missing`);
+        continue;
+      }
+      const sha = createHash6("sha256").update(readFileSync23(target)).digest("hex");
+      if (sha !== f.sha256) wrong.push(`${f.name} differs from the pinned partner bytes`);
+    }
+    checks.push({
+      id: `composition:${pin.pairKey}:module-verbatim`,
+      pass: wrong.length === 0,
+      ...wrong.length > 0 ? { detail: `pinned partner module not present verbatim at ${dir}/: ${wrong.join(", ")}` } : {}
+    });
+    const specifier = `./${dir}/${pin.entryComponent}`;
+    const imported = declaredImports(entrySource).includes(specifier);
+    checks.push({
+      id: `composition:${pin.pairKey}:imported`,
+      pass: imported,
+      ...imported ? {} : { detail: `host entry has no import declaration for the pinned module (expected \`from "${specifier}"\`)` }
+    });
+  }
+  return checks;
+}
+var composedModuleDir, safeSegment, MAX_PINNED_FILE_BYTES;
+var init_compose_pins = __esm({
+  "packages/generate/src/compose-pins.ts"() {
+    "use strict";
+    init_src();
+    init_src6();
+    init_brief();
+    init_bundle_emit();
+    composedModuleDir = (partnerName) => path33.posix.join("composed", partnerName);
+    safeSegment = (s) => /^[A-Za-z0-9][A-Za-z0-9._ -]*$/.test(s) && !s.includes("..");
+    MAX_PINNED_FILE_BYTES = 1024 * 1024;
+  }
+});
+
 // packages/generate/src/index.ts
 var init_src7 = __esm({
   "packages/generate/src/index.ts"() {
@@ -10694,13 +11369,14 @@ var init_src7 = __esm({
     init_consent();
     init_adapter();
     init_bundle_emit();
+    init_compose_pins();
   }
 });
 
 // packages/cli/src/font-guidance.ts
-import path32 from "node:path";
+import path34 from "node:path";
 function fontsUnprovenRemediation(setDir) {
-  const set = setDir === void 0 ? void 0 : path32.resolve(setDir);
+  const set = setDir === void 0 ? void 0 : path34.resolve(setDir);
   if (set !== void 0) {
     try {
       const needs = recordedFontNeeds(set);
@@ -10775,8 +11451,8 @@ __export(fonts_exports, {
   runFontsResolveSet: () => runFontsResolveSet,
   runFontsStatus: () => runFontsStatus
 });
-import { existsSync as existsSync26, readFileSync as readFileSync22 } from "node:fs";
-import path33 from "node:path";
+import { existsSync as existsSync28, readFileSync as readFileSync24 } from "node:fs";
+import path35 from "node:path";
 async function runFontsResolve(opts) {
   const result = await resolveFonts(opts.family, opts.weights, opts.cacheDir);
   const queryRefusal = systemFaceRefusal(opts.family.trim());
@@ -10797,7 +11473,7 @@ async function runFontsResolve(opts) {
   }
 }
 async function runFontsResolveSet(opts) {
-  const setDir = path33.resolve(process.env["INIT_CWD"] ?? process.cwd(), opts.set);
+  const setDir = path35.resolve(process.env["INIT_CWD"] ?? process.cwd(), opts.set);
   let needs = [];
   try {
     needs = recordedFontNeeds(setDir);
@@ -10880,16 +11556,16 @@ async function runFontsResolveSet(opts) {
   }
 }
 function runFontsStatus(opts) {
-  const manifestPath2 = path33.join(opts.cacheDir, "manifest.json");
-  if (!existsSync26(manifestPath2)) {
+  const manifestPath2 = path35.join(opts.cacheDir, "manifest.json");
+  if (!existsSync28(manifestPath2)) {
     fail(opts, ExitCode.FontsUnproven, {
       error: `no font cache at ${opts.cacheDir}`,
       code: "fonts-unresolved",
       remediation: `Run \`${tendrilCommand("fonts resolve --set <recording-dir>")}\` (or \`${tendrilCommand('fonts resolve "<Family>" --weights 400 500 600')}\`) first.`
     });
   }
-  const faces = JSON.parse(readFileSync22(manifestPath2, "utf8"));
-  const lockVerdicts = opts.lock !== void 0 ? checkFontLock(path33.resolve(opts.lock), opts.cacheDir) : null;
+  const faces = JSON.parse(readFileSync24(manifestPath2, "utf8"));
+  const lockVerdicts = opts.lock !== void 0 ? checkFontLock(path35.resolve(opts.lock), opts.cacheDir) : null;
   emitData(opts, { faces, lockVerdicts }, () => {
     for (const f of faces) process.stdout.write(`cached ${f.family} ${f.weight} (${f.sha256.slice(0, 12)}\u2026)
 `);
@@ -10933,13 +11609,13 @@ function familyMismatch(family, declared) {
 }
 function runFontsAdd(opts) {
   if (opts.set !== void 0) {
-    const declared = taskFontFamilies(path33.resolve(opts.set)) ?? [];
+    const declared = taskFontFamilies(path35.resolve(opts.set)) ?? [];
     const mismatch = familyMismatch(opts.family, declared);
     if (mismatch !== void 0) {
       fail(opts, ExitCode.InputValidation, {
         error: `the recording set does not declare a family named "${opts.family}" \u2014 it declares ${declared.map((d) => `"${d}"`).join(", ")}. Adding it under this name would cache a face the mount never matches, and scoring would keep refusing for the family that is still missing.`,
         code: "font-family-not-declared",
-        remediation: mismatch.nearest !== void 0 ? `Did you mean "${mismatch.nearest}"? ${tendrilCommand(`fonts add "${mismatch.nearest}" ${opts.weight} ${opts.file} --set ${path33.resolve(opts.set)}`)}` : `Use one of the declared families exactly as the recording spells it, or drop --set to add a family this set does not declare.`
+        remediation: mismatch.nearest !== void 0 ? `Did you mean "${mismatch.nearest}"? ${tendrilCommand(`fonts add "${mismatch.nearest}" ${opts.weight} ${opts.file} --set ${path35.resolve(opts.set)}`)}` : `Use one of the declared families exactly as the recording spells it, or drop --set to add a family this set does not declare.`
       });
     }
   } else {
@@ -10998,13 +11674,13 @@ cache them: ${tendrilCommand(`fonts add-system ${quoteArg(opts.family)}`)}
 }
 function runFontsAddSystem(opts) {
   if (opts.set !== void 0) {
-    const declared = taskFontFamilies(path33.resolve(opts.set)) ?? [];
+    const declared = taskFontFamilies(path35.resolve(opts.set)) ?? [];
     const mismatch = familyMismatch(opts.family, declared);
     if (mismatch !== void 0) {
       fail(opts, ExitCode.InputValidation, {
         error: `the recording set does not declare a family named "${opts.family}" \u2014 it declares ${declared.map((d) => `"${d}"`).join(", ")}. A face cached under a name the mount never matches leaves scoring refusing for the family that is still missing.`,
         code: "font-family-not-declared",
-        remediation: mismatch.nearest !== void 0 ? `Did you mean "${mismatch.nearest}"? ${tendrilCommand(`fonts add-system ${quoteArg(mismatch.nearest)} --set ${quoteArg(path33.resolve(opts.set))}`)}` : `Use one of the declared families exactly as the recording spells it, or drop --set.`
+        remediation: mismatch.nearest !== void 0 ? `Did you mean "${mismatch.nearest}"? ${tendrilCommand(`fonts add-system ${quoteArg(mismatch.nearest)} --set ${quoteArg(path35.resolve(opts.set))}`)}` : `Use one of the declared families exactly as the recording spells it, or drop --set.`
       });
     }
   } else {
@@ -11056,10 +11732,13 @@ var init_fonts = __esm({
 // packages/cli/src/commands/verify.ts
 var verify_exports = {};
 __export(verify_exports, {
+  COMPOSE_ON_GENERATE_ARMED: () => COMPOSE_ON_GENERATE_ARMED,
   NO_ROLE_MANIFEST: () => NO_ROLE_MANIFEST,
   ROLES_NOT_RESOLVED: () => ROLES_NOT_RESOLVED,
   checkSummarySegments: () => checkSummarySegments,
   compositionReport: () => compositionReport,
+  crossCompositionDemotions: () => crossCompositionDemotions,
+  crossCompositionLines: () => crossCompositionLines,
   eyeCheck: () => eyeCheck,
   failureTally: () => failureTally,
   foldConfigStatus: () => foldConfigStatus,
@@ -11071,15 +11750,15 @@ __export(verify_exports, {
   resolveComposition: () => resolveComposition,
   runVerify: () => runVerify
 });
-import { existsSync as existsSync27, readFileSync as readFileSync23 } from "node:fs";
-import path34 from "node:path";
+import { existsSync as existsSync29, readFileSync as readFileSync25 } from "node:fs";
+import path36 from "node:path";
 function interactionCoverage(behaviors) {
   const parity = behaviors.filter((b) => b.id.startsWith("parity:"));
-  const interaction = behaviors.filter((b) => !b.id.startsWith("prelude:") && !b.id.startsWith("parity:"));
+  const interaction = behaviors.filter((b) => !b.id.startsWith("prelude:") && !b.id.startsWith("parity:") && !b.id.startsWith("composition:"));
   return {
     interactionChecks: interaction.length,
     interactionPassed: interaction.filter((b) => b.pass).length,
-    preludeChecks: behaviors.length - interaction.length - parity.length,
+    preludeChecks: behaviors.filter((b) => b.id.startsWith("prelude:")).length,
     parityChecks: parity.length,
     parityPassed: parity.filter((b) => b.pass).length,
     // Asymmetric on purpose (review finding F3): a parity PASS never
@@ -11179,7 +11858,61 @@ function checkSummarySegments(input) {
   const occ = occlusionReport(input.occlusion);
   const occlusion = "unavailable" in occ ? `occlusion not applicable (${NO_OVERLAY_DECLARED})` : `occlusion ${tally(input.occlusion)}`;
   const operability = "short" in input.operability ? `operability UNVERIFIED (${input.operability.short})` : `operability ${input.operability.passed}/${input.operability.checks} interaction`;
-  return ` \xB7 ${operability} \xB7 ${composition} \xB7 ${occlusion}`;
+  const cross = input.crossComposition === void 0 || input.crossComposition.rows.length === 0 && input.crossComposition.malformed === void 0 ? "" : input.crossComposition.malformed !== void 0 && input.crossComposition.rows.length === 0 ? ` \xB7 cross-composition NOT CHECKED (entries REJECTED)` : (() => {
+    const supported = input.crossComposition.rows.filter((r) => r.status === "supported" || r.status === "stale-supported").length;
+    const composed = supported > 0 ? `, ${input.crossComposition.composed ?? 0} composed` : "";
+    return ` \xB7 cross-composition ${supported}/${input.crossComposition.rows.length} supported${composed}${input.crossComposition.malformed !== void 0 ? " (some entries REJECTED)" : ""}`;
+  })();
+  return ` \xB7 ${operability} \xB7 ${composition} \xB7 ${occlusion}${cross}`;
+}
+function crossCompositionDemotions(rows, scoredReps, armed, composedPairs = /* @__PURE__ */ new Set()) {
+  const demote = [];
+  const orphanFailRows = [];
+  for (const row of rows) {
+    const failing = row.status === "partner-missing" || row.status === "partner-unreadable" || row.status === "unsupported" || row.status === "stale-unsupported";
+    const arming = armed && (row.status === "supported" || row.status === "stale-supported") && !composedPairs.has(row.key);
+    if (!failing && !arming) continue;
+    const reps = arming ? [...new Set(row.instances.map((i) => i.hostRep))] : row.affectedReps;
+    const reason = arming ? `confirmed composition NOT COMPOSED \u2014 the pinned partner module is not present verbatim with its import declared; re-run \`tendril engine brief\` for this set (the pins ride the payload) and regenerate (ADR-013, ${row.key})` : `confirmed composition ${row.status} \u2014 ${row.detail} (ADR-013)`;
+    for (const rep of reps) {
+      if (scoredReps.has(rep)) demote.push({ rep, reason });
+      else orphanFailRows.push({ rep, error: `confirmed composition names rep "${rep}", which this set does not score (${row.status}, pair ${row.key}) \u2014 the claim cannot be cleared; repair or re-decide the composition` });
+    }
+  }
+  return { demote, orphanFailRows };
+}
+function crossCompositionLines(input) {
+  const lines = [];
+  if (input.malformed !== void 0) {
+    const plural = input.malformed.includes(";") ? "ies" : "y";
+    lines.push(
+      `UNAVAILABLE cross-composition entr${plural} REJECTED (${input.malformed}) \u2014 the backstop did NOT run over the rejected entr${plural}; repair the manifest and re-verify. Instrument failure, not a clean bill.`
+    );
+  }
+  for (const row of input.rows) {
+    const isSupported = row.status === "supported" || row.status === "stale-supported";
+    const staleNote = row.status === "stale-supported" ? `; NOTE: ${row.detail}` : "";
+    if (isSupported && input.composedPairs.has(row.key)) {
+      lines.push(
+        `COMPOSITION COMPOSED ${row.displayName} [${row.key}] \u2014 pinned partner module present verbatim, import declared${staleNote}. Rendered-mount stamping and region crops are the named next increment; whole-frame pixels remain the pixel evidence.`
+      );
+    } else if (isSupported && input.armed) {
+      lines.push(
+        `COMPOSITION FAIL     ${row.displayName} [${row.key}] \u2014 confirmed but NOT COMPOSED (pinned module not present verbatim with its import declared)${staleNote} \u2014 the affected configs are demoted; re-run \`tendril engine brief\` for this set (the pins ride the payload) and regenerate`
+      );
+    } else if (isSupported) {
+      lines.push(
+        `COMPOSITION PENDING  ${row.displayName} [${row.key}] \u2014 confirmed, not composed in this bundle${staleNote}; verdict unchanged while compose-on-generate is disarmed (ADR-013 \xA73; a PIN ISSUE line below carries the cause when pinning itself failed)`
+      );
+    } else {
+      lines.push(`COMPOSITION FAIL     ${row.displayName} [${row.key}] \u2014 ${row.detail} \u2014 the affected configs are demoted`);
+    }
+  }
+  const restatesRow = /^confirmed pair .+ is (?:partner-missing|partner-unreadable|unsupported|stale-unsupported) — not pinned/;
+  for (const issue of input.pinIssues.filter((i) => !restatesRow.test(i))) {
+    lines.push(`COMPOSITION PIN ISSUE ${issue}`);
+  }
+  return lines;
 }
 function latticeCoverage(setManifest, scoredConfigs) {
   const lattice = setManifest.latticeNames?.length;
@@ -11224,7 +11957,7 @@ function compositionReport(input) {
 function eyeCheck(bundleDir) {
   return {
     command: tendrilCommand(`inspect "${bundleDir}"`),
-    sheetPath: path34.join(bundleDir, "verify-evidence", "inspect.html"),
+    sheetPath: path36.join(bundleDir, "verify-evidence", "inspect.html"),
     note: "magnified recorded-vs-rendered crops of every small node; scores cannot see shape. The command WRITES/refreshes the sheet at sheetPath \u2014 re-run it after every verify; an existing sheet may show stale crops."
   };
 }
@@ -11236,7 +11969,7 @@ function taskFromManifest(opts, manifest, setDir) {
   const adapterSlugs = Object.keys(manifest.propAdapter);
   const unmapped = recordedSlugs.filter((s) => !adapterSlugs.includes(s));
   const adapterOnly = adapterSlugs.filter((s) => !recordedSlugs.includes(s));
-  const registry = Object.values(TASKS).find((t) => path34.resolve(t.set) === path34.resolve(setDir));
+  const registry = Object.values(TASKS).find((t) => path36.resolve(t.set) === path36.resolve(setDir));
   const authored = (() => {
     if (registry !== void 0) return void 0;
     try {
@@ -11275,19 +12008,19 @@ function taskFromManifest(opts, manifest, setDir) {
 }
 async function runVerify(opts) {
   const callerCwd = process.env["INIT_CWD"] ?? process.cwd();
-  const setOverride = opts.set !== void 0 ? path34.resolve(callerCwd, opts.set) : void 0;
-  opts = { ...opts, bundleDir: path34.resolve(callerCwd, opts.bundleDir), ...setOverride !== void 0 ? { set: setOverride } : {} };
-  if (!existsSync27(opts.bundleDir)) {
+  const setOverride = opts.set !== void 0 ? path36.resolve(callerCwd, opts.set) : void 0;
+  opts = { ...opts, bundleDir: path36.resolve(callerCwd, opts.bundleDir), ...setOverride !== void 0 ? { set: setOverride } : {} };
+  if (!existsSync29(opts.bundleDir)) {
     fail(opts, ExitCode.InputValidation, {
       error: `bundle directory not found: ${opts.bundleDir}`,
       code: "bundle-missing",
       remediation: "Point at a generated bundle directory (containing component.json, the entry module, and styles.css)."
     });
   }
-  const manifestPath2 = path34.join(opts.bundleDir, "component.json");
+  const manifestPath2 = path36.join(opts.bundleDir, "component.json");
   let manifest;
-  if (existsSync27(manifestPath2)) {
-    const { manifest: parsed, issues } = readBundleManifest(readFileSync23(manifestPath2, "utf8"));
+  if (existsSync29(manifestPath2)) {
+    const { manifest: parsed, issues } = readBundleManifest(readFileSync25(manifestPath2, "utf8"));
     if (issues.length > 0) {
       fail(opts, ExitCode.InputValidation, {
         error: `bundle manifest rejected at ingest: ${issues.map((i) => i.message).join("; ")}`,
@@ -11315,21 +12048,21 @@ async function runVerify(opts) {
     task = registry;
   } else if (manifest !== void 0) {
     const resolveSetDir = (p) => {
-      if (path34.isAbsolute(p)) return p;
-      const fromRepo = path34.resolve(REPO_ROOT, p);
-      if (existsSync27(fromRepo)) return fromRepo;
-      return path34.resolve(callerCwd, p);
+      if (path36.isAbsolute(p)) return p;
+      const fromRepo = path36.resolve(REPO_ROOT, p);
+      if (existsSync29(fromRepo)) return fromRepo;
+      return path36.resolve(callerCwd, p);
     };
     const setDir = opts.set ?? resolveSetDir(manifest.provenance.recordingSet.path);
-    if (!existsSync27(path34.join(setDir, "recording-set.json")) && !Object.values(TASKS).some((t) => path34.resolve(t.set) === path34.resolve(setDir))) {
+    if (!existsSync29(path36.join(setDir, "recording-set.json")) && !Object.values(TASKS).some((t) => path36.resolve(t.set) === path36.resolve(setDir))) {
       fail(opts, ExitCode.RecordingIncomplete, {
         error: `recording set not found or unmanifested: ${setDir}`,
         code: "recording-set-missing",
         remediation: "Pass --set <dir> pointing at the recording set this bundle was generated from."
       });
     }
-    const registry = Object.values(TASKS).find((t) => path34.resolve(t.set) === path34.resolve(setDir));
-    if (registry !== void 0 && !existsSync27(path34.join(setDir, "recording-set.json"))) {
+    const registry = Object.values(TASKS).find((t) => path36.resolve(t.set) === path36.resolve(setDir));
+    if (registry !== void 0 && !existsSync29(path36.join(setDir, "recording-set.json"))) {
       const recordedSlugs = registry.configs.map((c) => c.rep);
       const adapterSlugs = Object.keys(manifest.propAdapter);
       unmapped = recordedSlugs.filter((s) => !adapterSlugs.includes(s));
@@ -11355,9 +12088,9 @@ async function runVerify(opts) {
       warn(opts, `recording set content differs from the bundle's provenance stamp (${hash.slice(0, 12)}\u2026 vs ${manifest.provenance.recordingSet.hash.slice(0, 12)}\u2026) \u2014 scores apply to the CURRENT set`);
     }
     for (const name of [manifest.entry, "styles.css", "tokens.css"]) {
-      const p = path34.join(opts.bundleDir, name);
-      if (!existsSync27(p)) continue;
-      const issues = checkBundleSourceFile(name, new Uint8Array(readFileSync23(p)));
+      const p = path36.join(opts.bundleDir, name);
+      if (!existsSync29(p)) continue;
+      const issues = checkBundleSourceFile(name, new Uint8Array(readFileSync25(p)));
       if (issues.length > 0) {
         fail(opts, ExitCode.InputValidation, {
           error: `bundle source rejected at ingest: ${issues.map((i) => i.message).join("; ")}`,
@@ -11395,7 +12128,7 @@ async function runVerify(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) => !existsSync27(path34.join(task.set, c.rep, "get_screenshot.json")) || !existsSync27(path34.join(task.set, c.rep, "get_metadata.json"))
+    (c) => !existsSync29(path36.join(task.set, c.rep, "get_screenshot.json")) || !existsSync29(path36.join(task.set, c.rep, "get_metadata.json"))
   );
   if (missing.length > 0) {
     fail(opts, ExitCode.RecordingIncomplete, {
@@ -11405,16 +12138,26 @@ async function runVerify(opts) {
     });
   }
   const bar = BARS2[opts.bar];
-  const evidenceDir = path34.join(opts.bundleDir, "verify-evidence");
+  const evidenceDir = path36.join(opts.bundleDir, "verify-evidence");
   const scores = await scoreBundleForTask(task, opts.bundleDir, bar, { evidenceDir, onProgress: emitProgress });
   const quality = await checkBundleQuality(opts.bundleDir, task.entry, { dir: task.set, reps: task.configs.map((c) => c.rep) });
-  const bundleCss = ["tokens.css", "styles.css"].map((f) => path34.join(opts.bundleDir, f)).filter((f) => existsSync27(f)).map((f) => readFileSync23(f, "utf8")).join("\n");
+  const bundleCss = ["tokens.css", "styles.css"].map((f) => path36.join(opts.bundleDir, f)).filter((f) => existsSync29(f)).map((f) => readFileSync25(f, "utf8")).join("\n");
   const occlusion = await checkSiblingOcclusion(task, opts.bundleDir, bundleCss);
   const parity = await checkHoverParity(task, opts.bundleDir, authorityConfigs ?? task.configs);
   const behaviors = [...await checkBehaviors(task, opts.bundleDir), ...parity];
   const structural = roles !== void 0 ? await checkStructuralComposition(task, opts.bundleDir, roles) : [];
   const regionsOut = roles !== void 0 ? interiorRegions(task.set, roles) : void 0;
   const crops = regionsOut !== void 0 && "regions" in regionsOut ? await checkCropComposition(task, opts.bundleDir, regionsOut.regions) : void 0;
+  const crossComposition = confirmedCompositionStatus(task.set);
+  if (crossComposition.malformed !== void 0) {
+    warn(opts, `compositions extension REJECTED (${crossComposition.malformed}) \u2014 the cross-bundle backstop did NOT run over it; repair the manifest entry and re-verify. This is an instrument failure, not a clean bill.`);
+  }
+  const verifyCallerCwd = process.env["INIT_CWD"] ?? process.cwd();
+  const verifyPins = crossComposition.rows.length > 0 ? composedPins(task.set, [opts.library !== void 0 ? path36.resolve(verifyCallerCwd, opts.library) : verifyCallerCwd]) : { pins: [], issues: [] };
+  const verifyComposedChecks = composedChecks(opts.bundleDir, task.entry, verifyPins.pins);
+  const composedPairs = new Set(
+    verifyPins.pins.filter((pin) => verifyComposedChecks.filter((c) => c.id.startsWith(`composition:${pin.pairKey}:`)).every((c) => c.pass)).map((pin) => pin.pairKey)
+  );
   const demotions = /* @__PURE__ */ new Map();
   const demote = (rep, reason) => {
     demotions.set(rep, [...demotions.get(rep) ?? [], reason]);
@@ -11424,13 +12167,20 @@ async function runVerify(opts) {
   if (crops !== void 0) {
     for (const c of crops) if (!c.pass) demote(c.id.split(":")[1] ?? "", "composition crop failed (A1.4)");
   }
+  const scoredReps = /* @__PURE__ */ new Set([...scores.map((s) => s.rep), ...unmapped]);
+  const crossOutcome = crossCompositionDemotions(crossComposition.rows, scoredReps, COMPOSE_ON_GENERATE_ARMED, composedPairs);
+  for (const d of crossOutcome.demote) demote(d.rep, d.reason);
   const folded = scores.map((s) => foldConfigStatus(s, demotions.get(s.rep), substitutedFamilies));
   const absentInkDemoted = scores.filter((_, i) => folded[i].absentInkDemoted).map((s) => s.rep);
   const statuses = [
     ...folded.map((f) => f.row),
     // ADR-010 §2 anti-gaming: recorded configs the adapter does not map
     // are FAILs, never silently absent.
-    ...unmapped.map((rep) => ({ rep, similarity: 0, inkRecall: 0, pass: false, status: "fail", error: "not mapped by the bundle's prop adapter" }))
+    ...unmapped.map((rep) => ({ rep, similarity: 0, inkRecall: 0, pass: false, status: "fail", error: "not mapped by the bundle's prop adapter" })),
+    // ADR-013 2c-i: a confirmed-composition claim naming a rep this
+    // set does not score is a loud synthetic FAILURE, never a printed
+    // contradiction over an unchanged verdict.
+    ...crossOutcome.orphanFailRows.map((o) => ({ rep: o.rep, similarity: 0, inkRecall: 0, pass: false, status: "fail", error: o.error }))
   ];
   const behaviorFailures = behaviors.filter((b) => !b.pass);
   const structuralFailures = structural.filter((s) => !s.pass);
@@ -11497,6 +12247,19 @@ async function runVerify(opts) {
     // occlusionReport): the agent channel had no counterpart to the
     // human line's "occlusion not applicable (no overlay declared)".
     occlusionCheck: occlusionReport(occlusion),
+    // ADR-013 2c: the confirmed-composition backstop rows (re-derived
+    // from recordings, never trusted from the manifest), the composed
+    // checks (pinned bytes verbatim + import), and the pin issues.
+    ...crossComposition.rows.length > 0 || crossComposition.malformed !== void 0 ? {
+      crossComposition: {
+        rows: crossComposition.rows,
+        checks: verifyComposedChecks,
+        composedPairs: [...composedPairs],
+        pinIssues: verifyPins.issues,
+        ...crossComposition.malformed !== void 0 ? { malformed: crossComposition.malformed } : {},
+        note: "COMPOSED means the pinned partner module is present verbatim with its import declared; while compose-on-generate is disarmed (ADR-013 \xA73, re-arms with rendered-mount stamping) an uncomposed supported pair is DISCLOSED, never demoted \u2014 and whole-frame pixels remain the pixel evidence for composed regions"
+      }
+    } : {},
     configs: statuses,
     behaviors,
     evidence: { dir: evidenceDir, files: "per config: <rep>-render.png, <rep>-ref.png, <rep>-diff.png" },
@@ -11543,7 +12306,7 @@ async function runVerify(opts) {
     process.stdout.write(
       `
 ${certified}/${statuses.length} certified \xB7 ${report.coverage.pass}/${statuses.length} \u2265 pass bar \xB7 behaviors ${behaviors.length - behaviorFailures.length}/${behaviors.length}${checkSummarySegments(
-        { availability, structural, crops, occlusion, operability }
+        { availability, structural, crops, occlusion, operability, crossComposition: { rows: crossComposition.rows, ...crossComposition.malformed !== void 0 ? { malformed: crossComposition.malformed } : {}, composed: composedPairs.size } }
       )}
 `
     );
@@ -11603,9 +12366,19 @@ ${certified}/${statuses.length} certified \xB7 ${report.coverage.pass}/${statuse
         );
       }
     }
+    for (const line of crossCompositionLines({
+      rows: crossComposition.rows,
+      composedPairs,
+      armed: COMPOSE_ON_GENERATE_ARMED,
+      pinIssues: verifyPins.issues,
+      ...crossComposition.malformed !== void 0 ? { malformed: crossComposition.malformed } : {}
+    })) {
+      process.stdout.write(`${line}
+`);
+    }
     process.stdout.write(`environment: chrome=${report.environment.chromeVersion ?? report.environment.chrome} fonts=${report.environment.fontsManifestSha256 ?? "UNRESOLVED"}
 `);
-    const shippedFonts = requiredFontsManifest(cssFontFamilies(["styles.css", "tokens.css"].map((f) => path34.join(opts.bundleDir, f)).filter((f) => existsSync27(f)).map((f) => readFileSync23(f, "utf8")).join("\n")));
+    const shippedFonts = requiredFontsManifest(cssFontFamilies(["styles.css", "tokens.css"].map((f) => path36.join(opts.bundleDir, f)).filter((f) => existsSync29(f)).map((f) => readFileSync25(f, "utf8")).join("\n")));
     if (shippedFonts.length > 0 && substitutedFamilies.length === 0) {
       process.stdout.write(`fonts: scored with Tendril-cache faces \u2014 a consuming app must provision the same families (the bundle ships fonts.css when faces are shippable; sha-pinned list in component.json requiredFonts)
 `);
@@ -11658,7 +12431,7 @@ ${certified}/${statuses.length} certified \xB7 ${report.coverage.pass}/${statuse
     process.exitCode = ExitCode.VerificationFailed;
   }
 }
-var BARS2, NO_INTERACTIVE_POSES, NO_ROLE_MANIFEST, ROLES_NOT_RESOLVED, UNSTAMPED_ROLES, NO_OVERLAY_DECLARED;
+var BARS2, NO_INTERACTIVE_POSES, NO_ROLE_MANIFEST, ROLES_NOT_RESOLVED, UNSTAMPED_ROLES, COMPOSE_ON_GENERATE_ARMED, NO_OVERLAY_DECLARED;
 var init_verify = __esm({
   "packages/cli/src/commands/verify.ts"() {
     "use strict";
@@ -11685,6 +12458,7 @@ var init_verify = __esm({
       unavailable: "this run never resolved a role manifest \u2014 the legacy --task adapter and pre-manifest reference sets skip the set's roles block entirely, so composition (structural + crop) was NEVER CHECKED and the set was never asked what it declares; nothing here says the main renders the SHIPPED part modules rather than a pixel-identical re-implementation"
     });
     UNSTAMPED_ROLES = "unstamped";
+    COMPOSE_ON_GENERATE_ARMED = false;
     NO_OVERLAY_DECLARED = "no overlay declared";
   }
 });
@@ -11695,18 +12469,18 @@ __export(engine_exports, {
   runEngineBrief: () => runEngineBrief,
   runEngineScore: () => runEngineScore
 });
-import { appendFileSync, existsSync as existsSync28, mkdirSync as mkdirSync8, readFileSync as readFileSync24, writeFileSync as writeFileSync12 } from "node:fs";
-import path35 from "node:path";
+import { appendFileSync, existsSync as existsSync30, mkdirSync as mkdirSync8, readFileSync as readFileSync26, writeFileSync as writeFileSync12 } from "node:fs";
+import path37 from "node:path";
 function resolveEngineTask(opts, callerCwd) {
-  const asPath = path35.resolve(callerCwd, opts.taskOrSet);
-  const isSet = existsSync28(path35.join(asPath, "recording-set.json"));
+  const asPath = path37.resolve(callerCwd, opts.taskOrSet);
+  const isSet = existsSync30(path37.join(asPath, "recording-set.json"));
   const registry = TASKS[opts.taskOrSet];
   if (registry !== void 0 && !isSet) return { task: registry, name: opts.taskOrSet, ref: opts.taskOrSet, disclosures: [], interactionEvidence: void 0 };
   if (isSet) {
     try {
       const authored = authorTaskFromSet(asPath);
       for (const d of authored.disclosures) warn(opts, d);
-      return { task: authored.task, name: path35.basename(asPath), ref: asPath, disclosures: authored.disclosures, interactionEvidence: authored.api.interactionEvidence, apiPin: { props: authored.api.apiPin.props, forcedStates: authored.api.apiPin.forcedStates } };
+      return { task: authored.task, name: path37.basename(asPath), ref: asPath, disclosures: authored.disclosures, interactionEvidence: authored.api.interactionEvidence, apiPin: { props: authored.api.apiPin.props, forcedStates: authored.api.apiPin.forcedStates } };
     } catch (err) {
       fail(opts, ExitCode.InputValidation, {
         error: `cannot author a task from ${asPath}: ${err instanceof Error ? err.message.split("\n")[0] : String(err)}`,
@@ -11733,9 +12507,9 @@ ${disclosures.map((d) => `- ${d}`).join("\n")}` : "";
   const brief = buildBrief(task.systemApi, bar, { colorScheme: recordingIsDark(task) ? "dark" : "light" }) + disclosureBlock;
   const segments = buildSegments(task, "files");
   let notRecorded;
-  const manifestPath2 = path35.join(task.set, "recording-set.json");
-  if (existsSync28(manifestPath2)) {
-    notRecorded = JSON.parse(readFileSync24(manifestPath2, "utf8")).notRecorded;
+  const manifestPath2 = path37.join(task.set, "recording-set.json");
+  if (existsSync30(manifestPath2)) {
+    notRecorded = JSON.parse(readFileSync26(manifestPath2, "utf8")).notRecorded;
   }
   const unverified = notRecorded !== void 0 && notRecorded !== "" ? `
 
@@ -11743,7 +12517,7 @@ ${disclosures.map((d) => `- ${d}`).join("\n")}` : "";
 DO NOT INVENT PIXELS FOR THESE POSES. Implement them ONLY as the composition of recorded per-axis truth (the custom-property composition rule: one paint axis sets variables, the other consumes) and list every such pose in your report as UNRECORDED-COMPOSED. Recording them is the real fix: re-plan the set (full matrix is the default) and record the missing poses.
 ${notRecorded}` : "";
   let fontProvisioning;
-  if (existsSync28(manifestPath2)) {
+  if (existsSync30(manifestPath2)) {
     const missingFams = unprovisionedFamilies(task.set);
     const unprovided = unprovisionedFaces(task.set);
     const weightOnly = missingFams.length === 0;
@@ -11765,13 +12539,31 @@ ${notRecorded}` : "";
       };
     }
   }
-  const payload = `${brief}${unverified}
+  const pinsResult = composedPins(task.set, [opts.library !== void 0 ? path37.resolve(callerCwd, opts.library) : callerCwd]);
+  const jsxProp = ([k, v]) => typeof v === "string" ? `${k}=${JSON.stringify(v)}` : `${k}={${JSON.stringify(v)}}`;
+  const composedBlock = pinsResult.pins.length === 0 && pinsResult.issues.length === 0 ? "" : (pinsResult.pins.length > 0 ? `
+
+=== COMPOSED REGIONS (ADR-013 \u2014 each pair below was CONFIRMED BY A HUMAN; the pinned modules are PRESCRIBED API) ===
+CANON AMENDMENT for this task: "no imports beyond react/react-dom" is amended to ADDITIONALLY allow importing exactly the pinned modules below \u2014 nothing else. Write every pinned file VERBATIM (byte-for-byte) at the given candidate path; any edit fails the composition checks. Render the pinned entry component for each listed region with exactly the listed props; do not re-implement those pixels. The pinned styles/tokens CSS is injected at scoring time alongside yours \u2014 do not copy its rules into your own stylesheets.
+` + pinsResult.pins.map(
+    (pin) => `
+PIN ${pin.partnerName} [pair ${pin.pairKey}] \u2014 import from "./${composedModuleDir(pin.partnerName)}/${pin.entryComponent}"
+` + pin.instances.map((i) => `  region ${i.hostRep}/${i.instanceId}: <${pin.entryComponent} ${Object.entries(i.props).map(jsxProp).join(" ")} /> (pose ${i.partnerRep})`).join("\n") + pin.moduleFiles.map((f) => `
+--- write VERBATIM to ${composedModuleDir(pin.partnerName)}/${f.name} (sha256 ${f.sha256}) ---
+${f.content}`).join("")
+  ).join("\n") : `
+
+=== COMPOSED REGIONS (ADR-013 \u2014 confirmed pairs exist, but NONE could be pinned) ===
+`) + (pinsResult.issues.length > 0 ? `
+NOT PINNED (named, never silent \u2014 these confirmed pairs could not be pinned): implement those regions inline and state it in your report. Verify will DISCLOSE each such pair as confirmed-but-not-composed; where the cause below is fixable (e.g. the partner bundle is missing), fixing it and re-running brief is the better path:
+${pinsResult.issues.map((i) => `- ${i}`).join("\n")}` : "");
+  const payload = `${brief}${unverified}${composedBlock}
 
 === TASK PAYLOAD (recorded truth, verbatim) ===
 ${segments}`;
-  const payloadFile = path35.resolve(callerCwd, opts.out ?? `tendril-out/${name}-brief.md`);
-  const candidateDirSuggestion = path35.resolve(callerCwd, `tendril-out/${name}-candidate`);
-  mkdirSync8(path35.dirname(payloadFile), { recursive: true });
+  const payloadFile = path37.resolve(callerCwd, opts.out ?? `tendril-out/${name}-brief.md`);
+  const candidateDirSuggestion = path37.resolve(callerCwd, `tendril-out/${name}-candidate`);
+  mkdirSync8(path37.dirname(payloadFile), { recursive: true });
   writeFileSync12(payloadFile, payload);
   emitData(
     opts,
@@ -11784,6 +12576,10 @@ ${segments}`;
       ...opts.model !== void 0 ? { declaredModel: opts.model } : {},
       ...notRecorded !== void 0 && notRecorded !== "" ? { notRecorded } : {},
       ...fontProvisioning !== void 0 ? { fontProvisioning } : {},
+      // ADR-013: composition is IN PLAY for this task — an orchestrator
+      // reading only this JSON must be able to see it (the payload file
+      // carries the pins themselves).
+      ...pinsResult.pins.length > 0 || pinsResult.issues.length > 0 ? { composition: { pinnedPairs: pinsResult.pins.map((p) => p.pairKey), pinIssues: pinsResult.issues } } : {},
       modelSelection: {
         instruction: "The model declaration is MECHANICAL: `engine score` refuses to run without --model. ONLY ask when the answer can take effect \u2014 i.e. you can delegate implementation to an agent running the chosen model; if you cannot delegate in this session, skip the question, build as yourself, and declare your own model honestly (a question whose answer changes nothing wastes the user's trust \u2014 measured, second Windows run). When you do ask: BEFORE reading the payload, using the template below verbatim where your host renders option dialogs. The audience is non-technical: plain cost/quality language, no model knowledge assumed. In a non-interactive session pick the balanced tier, state the reason in your report, and declare it \u2014 a silent default is not possible.",
         questionTemplate: {
@@ -11806,8 +12602,11 @@ ${segments}`;
         // arguments, and a placeholder is the other half of the same
         // defect — a command the reader has to finish is one they can
         // finish wrongly.
+        // --library rides along when brief ran with one: the score
+        // command must search the same bundle roots the pins came
+        // from, or the oracle and the brief describe different worlds.
         `Run \`${tendrilCommand(
-          `engine score ${quoteArg(ref)} ${quoteArg(candidateDirSuggestion)} --bar ${opts.bar} --model ${opts.model ?? "<declared-model>"} --json`
+          `engine score ${quoteArg(ref)} ${quoteArg(candidateDirSuggestion)} --bar ${opts.bar} --model ${opts.model ?? "<declared-model>"}${opts.library !== void 0 ? ` --library ${quoteArg(path37.resolve(callerCwd, opts.library))}` : ""} --json`
         )}\` \u2014 the CLI is the sole judge, and it refuses to score an undeclared model. If you wrote the bundle elsewhere, pass that directory instead.`,
         "Apply the returned feedback and re-score. Stop when all checks pass. Two consecutive non-improving scores mean INSPECT the verify-evidence diffs before deciding \u2014 stop only when inspection yields no fix hypothesis (a measured run was byte-identical twice, then went 27/27 after reading the diffs).",
         "Never edit recording sets; never claim scores yourself \u2014 only the score command's output counts."
@@ -11822,8 +12621,8 @@ ${segments}`;
   );
 }
 function appendScoreHistory(candidateDir, entry) {
-  const file = path35.join(candidateDir, "score-history.jsonl");
-  const starts = existsSync28(file) ? readFileSync24(file, "utf8").split("\n").filter((l) => l.includes('"event":"round-start"')).length : 0;
+  const file = path37.join(candidateDir, "score-history.jsonl");
+  const starts = existsSync30(file) ? readFileSync26(file, "utf8").split("\n").filter((l) => l.includes('"event":"round-start"')).length : 0;
   const round = entry.event === "round-start" ? starts + 1 : Math.max(1, starts);
   appendFileSync(file, `${JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), round, ...entry })}
 `);
@@ -11831,9 +12630,9 @@ function appendScoreHistory(candidateDir, entry) {
 async function runEngineScore(opts) {
   requireEntitlement(opts);
   const callerCwd = process.env["INIT_CWD"] ?? process.cwd();
-  const candidateDir = path35.resolve(callerCwd, opts.candidateDir);
+  const candidateDir = path37.resolve(callerCwd, opts.candidateDir);
   const { task, name, apiPin, interactionEvidence } = resolveEngineTask(opts, callerCwd);
-  if (!existsSync28(candidateDir)) {
+  if (!existsSync30(candidateDir)) {
     fail(opts, ExitCode.InputValidation, {
       error: `candidate directory not found: ${candidateDir}`,
       code: "candidate-missing",
@@ -11858,10 +12657,10 @@ async function runEngineScore(opts) {
   for (const g of missingWeights(task.set)) {
     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)`);
   }
-  if (opts.rebind !== true && existsSync28(path35.join(candidateDir, "component.json"))) {
+  if (opts.rebind !== true && existsSync30(path37.join(candidateDir, "component.json"))) {
     const prior = (() => {
       try {
-        const read = readBundleManifest(readFileSync24(path35.join(candidateDir, "component.json"), "utf8"));
+        const read = readBundleManifest(readFileSync26(path37.join(candidateDir, "component.json"), "utf8"));
         return read.manifest === void 0 ? { unreadable: true } : { hash: read.manifest.provenance.recordingSet.hash, path: read.manifest.provenance.recordingSet.path };
       } catch {
         return { unreadable: true };
@@ -11883,10 +12682,12 @@ async function runEngineScore(opts) {
     }
   }
   const bar = BARS3[opts.bar];
-  const evidenceDir = path35.join(candidateDir, "verify-evidence");
+  const evidenceDir = path37.join(candidateDir, "verify-evidence");
   const scores = await scoreBundleForTask(task, candidateDir, bar, { evidenceDir, onProgress: emitProgress });
   const parity = await checkHoverParity(task, candidateDir, task.configs);
-  const behaviors = [...await checkBehaviors(task, candidateDir), ...parity];
+  const scorePins = composedPins(task.set, [opts.library !== void 0 ? path37.resolve(callerCwd, opts.library) : callerCwd]);
+  const composition = composedChecks(candidateDir, task.entry, scorePins.pins);
+  const behaviors = [...await checkBehaviors(task, candidateDir), ...parity, ...composition];
   const parityCoverage = parity.length > 0 ? `${parity.filter((p) => p.pass).length}/${parity.length} hover-forced configs` : "not applicable (no hover-forced configs in this set)";
   const obj = objective(scores, behaviors);
   const total = scores.length + behaviors.length;
@@ -11911,12 +12712,16 @@ MISSING FEATURES (absent-ink clusters \u2014 recorded ink your render leaves now
 ${absentFindings.join("\n")}` : "";
   const certificationFeedback = `${absentBlock}
 
-CERTIFICATION: ${certifiedReps.length}/${scores.length} configs at the certification bar (sim \u2265${certBar.sim} AND ink \u2265${certBar.ink}, exact values, after parity demotion \u2014 composition checks at verify can demote further).${certifiedReps.length < scores.length ? ` Below cert: ${scores.filter((sc) => !certifiedSet.has(sc.rep)).map((sc) => sc.rep).join(", ")}.` : ""}
+CERTIFICATION: ${certifiedReps.length}/${scores.length} configs at the certification bar (sim \u2265${certBar.sim} AND ink \u2265${certBar.ink}, exact values, after parity demotion \u2014 verify's A1.4 structural/crop checks can demote further).${certifiedReps.length < scores.length ? ` Below cert: ${scores.filter((sc) => !certifiedSet.has(sc.rep)).map((sc) => sc.rep).join(", ")}.` : ""}
 METRIC DEADBAND (read before iterating on near-misses): the scored similarity/ink deliberately tolerate \xB11px edge shift and antialiased-edge differences \u2014 cross-rasterizer noise absorption. A change entirely inside that band moves these numbers by EXACTLY ZERO (working as designed, not a stuck scorer). The per-config \`exact\` fields in the JSON are tolerance-free and move first: compare exact across rounds to confirm a small fix landed, and stop iterating when only exact moves \u2014 the bar reads the tolerant numbers.`;
   const stampNotice = `
 
 PROVENANCE STAMP: this scoring call itself (the Tendril CLI) just wrote/refreshed a comment on line 1 of styles.css carrying these scores, marked non-authoritative. If your editor or host reports styles.css was modified externally, that modification is this scorer \u2014 expected, not tampering. Keep the comment; it self-invalidates on any edit and \`tendril verify\` recomputes it.`;
-  const feedback = buildFeedback(scores, behaviors, bar, "files") + certificationFeedback + stampNotice + qualityFeedback;
+  const compositionFeedback = scorePins.issues.length > 0 ? `
+
+COMPOSITION PINS (ADR-013): ${scorePins.issues.length} confirmed pair(s) could not be pinned \u2014 verify will disclose each as confirmed-but-not-composed; not fixable by editing the candidate:
+${scorePins.issues.map((i) => `- ${i}`).join("\n")}` : "";
+  const feedback = buildFeedback(scores, behaviors, bar, "files") + certificationFeedback + compositionFeedback + stampNotice + qualityFeedback;
   const emitted = emitBundleV1({
     bundleDir: candidateDir,
     task,
@@ -11978,6 +12783,10 @@ PROVENANCE STAMP: this scoring call itself (the Tendril CLI) just wrote/refreshe
       // fixing verify's channel and not this one would have left the
       // reader who actually acts on it exactly where they were.
       coverage: { ...coverage, operabilityCheck: operability },
+      // Same naming as verify's report block: the checks themselves ride
+      // `behaviors` (composition: ids); this carries what CANNOT ride
+      // there — which pairs pinned and which could not, with causes.
+      ...scorePins.pins.length > 0 || scorePins.issues.length > 0 ? { crossComposition: { pinnedPairs: scorePins.pins.map((p) => p.pairKey), pinIssues: scorePins.issues } } : {},
       parityCoverage,
       evidenceDir,
       bundleManifest: emitted.written[0],
@@ -11989,12 +12798,14 @@ PROVENANCE STAMP: this scoring call itself (the Tendril CLI) just wrote/refreshe
       // bundles verify then FAILED on the interaction-evidence gate —
       // the oracle must say what verify will say, including this.
       ...evidenceUnverified ? { interactionEvidenceUnverified: true, verifyWillFail: "interaction-evidence \u2014 the recording proves interactive poses none of the authored behaviors cover; not fixable from component code; REPORT it, do not iterate on it" } : {},
-      certification: { certified: certifiedReps.length, total: scores.length, bar: certBar, note: "tierOf on exact values + parity and absent-ink demotion; verify's composition checks can demote further" }
+      certification: { certified: certifiedReps.length, total: scores.length, bar: certBar, note: "tierOf on exact values + parity and absent-ink demotion; verify's A1.4 structural/crop checks can demote further" }
     },
     () => {
       for (const s of scores) process.stdout.write(`${s.pass ? certifiedSet.has(s.rep) ? "CERT" : "PASS" : "FAIL"} ${s.rep}: sim=${s.similarity} ink=${s.inkRecall}${s.error !== void 0 ? ` [${s.error}]` : ""}
 `);
       for (const b of behaviors) process.stdout.write(`${b.pass ? "PASS" : "FAIL"} ${b.id}${b.detail !== void 0 ? ` [${b.detail}]` : ""}
+`);
+      for (const i of scorePins.issues) process.stdout.write(`PIN ISSUE ${i}
 `);
       process.stdout.write(`
 ${obj[0]}/${total} \xB7 certified ${certifiedReps.length}/${total} \xB7 floor=${obj[1].toFixed(3)} \xB7 mean=${obj[2].toFixed(3)} \xB7 evidence: ${evidenceDir}
@@ -12054,11 +12865,11 @@ var codeconnect_exports = {};
 __export(codeconnect_exports, {
   runCodeConnect: () => runCodeConnect
 });
-import { existsSync as existsSync29, readFileSync as readFileSync25, writeFileSync as writeFileSync13 } from "node:fs";
-import path36 from "node:path";
+import { existsSync as existsSync31, readFileSync as readFileSync27, writeFileSync as writeFileSync13 } from "node:fs";
+import path38 from "node:path";
 function runCodeConnect(opts) {
   const callerCwd = process.env["INIT_CWD"] ?? process.cwd();
-  const bundleDir = path36.resolve(callerCwd, opts.bundleDir);
+  const bundleDir = path38.resolve(callerCwd, opts.bundleDir);
   let url;
   try {
     url = new URL(opts.figmaUrl);
@@ -12074,7 +12885,7 @@ function runCodeConnect(opts) {
   }
   let manifest;
   try {
-    const read = readBundleManifest(readFileSync25(path36.join(bundleDir, "component.json"), "utf8"));
+    const read = readBundleManifest(readFileSync27(path38.join(bundleDir, "component.json"), "utf8"));
     if (read.manifest === void 0) throw new Error(read.issues.map((i) => i.message).join("; ") || "no component.json");
     manifest = read.manifest;
   } catch (err) {
@@ -12084,8 +12895,8 @@ function runCodeConnect(opts) {
       remediation: "Point at a bundle produced by the Tendril pipeline (it carries component.json), and verify it first."
     });
   }
-  const setDir = path36.resolve(callerCwd, opts.set ?? manifest.provenance.recordingSet.path);
-  if (!existsSync29(path36.join(setDir, "recording-set.json"))) {
+  const setDir = path38.resolve(callerCwd, opts.set ?? manifest.provenance.recordingSet.path);
+  if (!existsSync31(path38.join(setDir, "recording-set.json"))) {
     fail(opts, ExitCode.InputValidation, {
       error: `recording set not found at ${setDir}`,
       code: "codeconnect-no-set",
@@ -12106,10 +12917,10 @@ function runCodeConnect(opts) {
   const component = api.component;
   const recManifest = loadManifest(setDir);
   const poseNames = recManifest.latticeNames ?? recManifest.reps.map((r) => {
-    const meta = path36.join(setDir, r.slug, "get_metadata.json");
-    if (!existsSync29(meta)) return void 0;
+    const meta = path38.join(setDir, r.slug, "get_metadata.json");
+    if (!existsSync31(meta)) return void 0;
     try {
-      return /name="([^"]*)"/.exec(envelopeTextContent(JSON.parse(readFileSync25(meta, "utf8"))))?.[1];
+      return /name="([^"]*)"/.exec(envelopeTextContent(JSON.parse(readFileSync27(meta, "utf8"))))?.[1];
     } catch {
       return void 0;
     }
@@ -12167,7 +12978,7 @@ function runCodeConnect(opts) {
     axisLines.push(`const ${varName} = instance.getEnum(${q(axis)}, { ${entries.join(", ")} })`);
     fragmentVars.push(varName);
   }
-  const entryRel = path36.relative(callerCwd, path36.join(bundleDir, manifest.entry));
+  const entryRel = path38.relative(callerCwd, path38.join(bundleDir, manifest.entry));
   const trust = manifest.trustStatement.split("\n")[0] ?? "";
   const lines = [
     `// url=${opts.figmaUrl}`,
@@ -12188,7 +12999,7 @@ function runCodeConnect(opts) {
     `}`,
     ``
   ].join("\n");
-  const outFile = path36.resolve(callerCwd, opts.out ?? path36.join(bundleDir, `${component}.figma.ts`));
+  const outFile = path38.resolve(callerCwd, opts.out ?? path38.join(bundleDir, `${component}.figma.ts`));
   writeFileSync13(outFile, lines);
   emitData(
     opts,
@@ -12227,18 +13038,18 @@ var init_codeconnect = __esm({
 });
 
 // packages/mcp/src/server.ts
-import { createHash as createHash5 } from "node:crypto";
-import { existsSync as existsSync30, mkdtempSync as mkdtempSync3, readFileSync as readFileSync26, readdirSync as readdirSync9, writeFileSync as writeFileSync14 } from "node:fs";
+import { createHash as createHash7 } from "node:crypto";
+import { existsSync as existsSync32, mkdtempSync as mkdtempSync3, readFileSync as readFileSync28, readdirSync as readdirSync12, writeFileSync as writeFileSync14 } from "node:fs";
 import os7 from "node:os";
-import path37 from "node:path";
+import path39 from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 function sourceHash() {
-  const dir = path37.dirname(fileURLToPath6(import.meta.url));
-  const h = createHash5("sha256");
-  for (const f of readdirSync9(dir).filter((n) => n.endsWith(".ts")).sort()) {
+  const dir = path39.dirname(fileURLToPath6(import.meta.url));
+  const h = createHash7("sha256");
+  for (const f of readdirSync12(dir).filter((n) => n.endsWith(".ts")).sort()) {
     h.update(f);
-    h.update(readFileSync26(path37.join(dir, f)));
+    h.update(readFileSync28(path39.join(dir, f)));
   }
   return h.digest("hex").slice(0, 16);
 }
@@ -12246,27 +13057,27 @@ var REPO_ROOT3, CLI_BIN, BUNDLED_CLI, CLI_SPAWN, str, optStr, TOOLS, BOOT_HASH;
 var init_server = __esm({
   "packages/mcp/src/server.ts"() {
     "use strict";
-    REPO_ROOT3 = path37.resolve(path37.dirname(fileURLToPath6(import.meta.url)), "..", "..", "..");
-    CLI_BIN = path37.join(REPO_ROOT3, "packages", "cli", "src", "bin.ts");
-    BUNDLED_CLI = path37.join(path37.dirname(fileURLToPath6(import.meta.url)), "tendril.js");
-    CLI_SPAWN = existsSync30(BUNDLED_CLI) ? { cmd: process.execPath, prefix: [BUNDLED_CLI] } : { cmd: "npx", prefix: ["tsx", CLI_BIN] };
-    str = (d) => z12.string().describe(d);
-    optStr = (d) => z12.string().optional().describe(d);
+    REPO_ROOT3 = path39.resolve(path39.dirname(fileURLToPath6(import.meta.url)), "..", "..", "..");
+    CLI_BIN = path39.join(REPO_ROOT3, "packages", "cli", "src", "bin.ts");
+    BUNDLED_CLI = path39.join(path39.dirname(fileURLToPath6(import.meta.url)), "tendril.js");
+    CLI_SPAWN = existsSync32(BUNDLED_CLI) ? { cmd: process.execPath, prefix: [BUNDLED_CLI] } : { cmd: "npx", prefix: ["tsx", CLI_BIN] };
+    str = (d) => z13.string().describe(d);
+    optStr = (d) => z13.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: z12.object({
+        schema: z13.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: z12.array(z12.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: z13.array(z13.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: z12.array(z12.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: z12.array(z12.string()).optional().describe(`axis defaults as "Axis=Value" (from the user's defaultsToConfirm answers; may re-plan a set with nothing recorded yet)`),
+          metadataFiles: z13.array(z13.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: z13.array(z13.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")
         }),
@@ -12280,7 +13091,7 @@ var init_server = __esm({
           const single = i["metadata"];
           const parts = i["metadataParts"];
           if (single !== void 0 || parts !== void 0) {
-            const tmp = path37.join(mkdtempSync3(path37.join(os7.tmpdir(), "tendril-envelope-")), "response.txt");
+            const tmp = path39.join(mkdtempSync3(path39.join(os7.tmpdir(), "tendril-envelope-")), "response.txt");
             if (single !== void 0) {
               writeFileSync14(tmp, single);
               argvOut.push("--metadata-raw-file", tmp);
@@ -12302,10 +13113,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: z12.object({
-          write: z12.boolean().optional().describe("true = install into .claude/settings.local.json (the point of this tool); false/absent = just return the entries"),
-          figmaPrefix: z12.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: z12.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: z13.object({
+          write: z13.boolean().optional().describe("true = install into .claude/settings.local.json (the point of this tool); false/absent = just return the entries"),
+          figmaPrefix: z13.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: z13.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",
@@ -12319,23 +13130,23 @@ 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. 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: z12.object({}),
+        schema: z13.object({}),
         argv: () => ["doctor"]
       },
       {
         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: z12.object({ setDir: str("recording set directory") }),
+        schema: z13.object({ setDir: str("recording set directory") }),
         argv: (i) => ["record", "next", "--set", i["setDir"]]
       },
       {
         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: z12.object({
+        schema: z13.object({
           setDir: str("recording set directory"),
           rep: str("planned rep slug"),
-          tool: z12.enum(["get_screenshot"]).describe("get_screenshot"),
+          tool: z13.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"]]
@@ -12343,15 +13154,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), 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: z12.object({
+        schema: z13.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: z12.array(z12.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: z12.array(z12.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: z13.array(z13.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: z13.array(z13.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)")
@@ -12363,7 +13174,7 @@ var init_server = __esm({
           const bridge = (label, single, parts) => {
             if (single !== void 0 && parts !== void 0) throw new Error(`pass at most one of \`${label}\` and \`${label}Parts\``);
             if (single === void 0 && parts === void 0) return;
-            const tmp = path37.join(mkdtempSync3(path37.join(os7.tmpdir(), "tendril-envelope-")), "response.txt");
+            const tmp = path39.join(mkdtempSync3(path39.join(os7.tmpdir(), "tendril-envelope-")), "response.txt");
             if (single !== void 0) {
               writeFileSync14(tmp, single);
               argvOut.push(`--${label}-file`, tmp);
@@ -12384,7 +13195,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, set-level get_variable_defs, 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: z12.object({
+        schema: z13.object({
           setDir: str("recording set directory"),
           rep: str("planned rep slug, or __set__ for the set-level get_variable_defs"),
           // Enumerated, not a free string: this value reaches a file path.
@@ -12392,9 +13203,9 @@ var init_server = __esm({
           // (--tool "../../outside/victim" replaced a file outside the set,
           // exit 0). The sink in session.ts now contains the path too — this
           // is the second layer, and it makes the tool self-documenting.
-          tool: z12.enum(["get_design_context", "get_metadata", "get_screenshot", "get_variable_defs", "get_metadata_interior"]),
+          tool: z13.enum(["get_design_context", "get_metadata", "get_screenshot", "get_variable_defs", "get_metadata_interior"]),
           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: z12.array(z12.string()).optional().describe("when the response arrived as MULTIPLE output blocks: every block, in order, each verbatim \u2014 never hand-join blocks yourself"),
+          texts: z13.array(z13.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
@@ -12406,7 +13217,7 @@ var init_server = __esm({
           const file = i["file"];
           if ([text, texts, file].filter((x) => x !== void 0).length !== 1) throw new Error("pass exactly one of `text` (single-block response), `texts` (multi-block response), or `file` (a saved envelope)");
           if (file !== void 0) return [...base, "--file", file];
-          const tmp = path37.join(mkdtempSync3(path37.join(os7.tmpdir(), "tendril-envelope-")), "response.txt");
+          const tmp = path39.join(mkdtempSync3(path39.join(os7.tmpdir(), "tendril-envelope-")), "response.txt");
           if (text !== void 0) {
             writeFileSync14(tmp, text);
             return [...base, "--file", tmp, "--raw"];
@@ -12418,7 +13229,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: z12.object({
+        schema: z13.object({
           setDir: str("recording set directory"),
           rep: str("planned rep slug"),
           name: optStr("asset-<id>.<ext> (single-asset mode)"),
@@ -12439,13 +13250,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 token map is recorded. `complete` means USABLE by the next pipeline step, including the set-level get_variable_defs.",
-        schema: z12.object({ setDir: str("recording set directory") }),
+        schema: z13.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: z12.object({
+        schema: z13.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
@@ -12455,7 +13266,8 @@ var init_server = __esm({
           // choose, declare, and state the reason in your report.
           model: str("the model that will WRITE the implementation \u2014 ask the user when interactive; declare your reasoned choice when not"),
           bar: optStr("pass (default) or cert"),
-          out: optStr("payload file path override")
+          out: optStr("payload file path override"),
+          library: optStr("workspace root holding confirmed partners generated bundles (ADR-013 composed pins; default: the server's working directory)")
         }),
         argv: (i) => [
           "engine",
@@ -12464,19 +13276,21 @@ var init_server = __esm({
           "--model",
           i["model"],
           ...i["bar"] !== void 0 ? ["--bar", i["bar"]] : [],
-          ...i["out"] !== void 0 ? ["--out", i["out"]] : []
+          ...i["out"] !== void 0 ? ["--out", i["out"]] : [],
+          ...i["library"] !== void 0 ? ["--library", i["library"]] : []
         ]
       },
       {
         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.",
-        schema: z12.object({
+        schema: z13.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: z12.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: z13.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) => [
           "engine",
@@ -12487,13 +13301,14 @@ var init_server = __esm({
           ...i["host"] !== void 0 ? ["--host", i["host"]] : [],
           "--model",
           i["model"],
-          ...i["rebind"] === true ? ["--rebind"] : []
+          ...i["rebind"] === true ? ["--rebind"] : [],
+          ...i["library"] !== void 0 ? ["--library", i["library"]] : []
         ]
       },
       {
         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: z12.object({
+        schema: z13.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)"),
@@ -12511,27 +13326,29 @@ 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.",
-        schema: z12.object({
+        schema: z13.object({
           bundleDir: str("bundle directory to verify"),
           bar: optStr("pass (default) or cert"),
-          set: optStr("recording-set directory override")
+          set: optStr("recording-set directory override"),
+          library: optStr("workspace root holding confirmed partners generated bundles (ADR-013 composed pins; default: the server's working directory)")
         }),
         argv: (i) => [
           "verify",
           i["bundleDir"],
           ...i["bar"] !== void 0 ? ["--bar", i["bar"]] : [],
-          ...i["set"] !== void 0 ? ["--set", i["set"]] : []
+          ...i["set"] !== void 0 ? ["--set", i["set"]] : [],
+          ...i["library"] !== void 0 ? ["--library", i["library"]] : []
         ]
       },
       {
         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: z12.object({
+        schema: z13.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: z12.boolean().optional().describe("accept the cost consent (the user must have approved the spend)")
+          yes: z13.boolean().optional().describe("accept the cost consent (the user must have approved the spend)")
         }),
         argv: (i) => [
           "generate",
@@ -12562,13 +13379,13 @@ __export(permissions_exports, {
   runPermissions: () => runPermissions,
   writeSelection: () => writeSelection
 });
-import { existsSync as existsSync31, mkdirSync as mkdirSync9, readFileSync as readFileSync27, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync33, mkdirSync as mkdirSync9, readFileSync as readFileSync29, writeFileSync as writeFileSync15 } from "node:fs";
 import os8 from "node:os";
-import path38 from "node:path";
+import path40 from "node:path";
 function mergeAllowlist(file, entries, denyEntries = []) {
   let settings = {};
-  if (existsSync31(file) && readFileSync27(file, "utf8").trim() !== "") {
-    settings = JSON.parse(readFileSync27(file, "utf8"));
+  if (existsSync33(file) && readFileSync29(file, "utf8").trim() !== "") {
+    settings = JSON.parse(readFileSync29(file, "utf8"));
     if (settings === null || typeof settings !== "object" || Array.isArray(settings)) throw new Error("settings root is not an object");
   }
   const permissions = settings["permissions"] ??= {};
@@ -12588,7 +13405,7 @@ function mergeAllowlist(file, entries, denyEntries = []) {
   }
   if (added.length > 0 || denyAdded.length > 0) {
     allow.push(...added);
-    mkdirSync9(path38.dirname(file), { recursive: true });
+    mkdirSync9(path40.dirname(file), { recursive: true });
     writeFileSync15(file, `${JSON.stringify(settings, null, 2)}
 `);
   }
@@ -12653,7 +13470,7 @@ async function runPermissions(flags) {
   }
   if (flags.write) {
     const base = process.env["INIT_CWD"] ?? process.cwd();
-    const file = flags.user ? path38.join(os8.homedir(), ".claude", "settings.json") : path38.join(base, ".claude", "settings.local.json");
+    const file = flags.user ? path40.join(os8.homedir(), ".claude", "settings.json") : path40.join(base, ".claude", "settings.local.json");
     const { entries, denyEntries } = writeSelection(result, flags.user === true);
     if (flags.dryRun) {
       emitData(flags, { file, wouldAdd: entries, wouldDeny: denyEntries }, () => {
@@ -12796,30 +13613,255 @@ var init_permissions = __esm({
   }
 });
 
+// packages/cli/src/commands/compose.ts
+var compose_exports = {};
+__export(compose_exports, {
+  COMPOSE_DESCRIPTION: () => COMPOSE_DESCRIPTION,
+  runCompose: () => runCompose
+});
+import { createHash as createHash8 } from "node:crypto";
+import { existsSync as existsSync34, readFileSync as readFileSync30 } from "node:fs";
+import path41 from "node:path";
+function substitutionPairs(edges, hostSet) {
+  const pairs = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    if (e.hostSet !== hostSet || e.kind !== "substitution" || e.pose === void 0) continue;
+    const dirs = e.partners.map((p) => p.dir);
+    const key = pairKeyFor(hostSet, dirs);
+    if (!pairs.has(key)) {
+      pairs.set(key, {
+        key,
+        partnerDirs: dirs,
+        displayName: e.partners[0].displayName,
+        ...e.partners[0].figmaFile !== void 0 ? { figmaFile: e.partners[0].figmaFile } : {},
+        instances: [],
+        disclosures: []
+      });
+    }
+    const pair = pairs.get(key);
+    pair.instances.push({ hostRep: e.hostRep, instanceId: e.instanceId, poseVariantNodeId: e.pose.variantNodeId });
+    for (const d of e.disclosures) if (!pair.disclosures.includes(d)) pair.disclosures.push(d);
+  }
+  return [...pairs.values()];
+}
+function runCompose(flags) {
+  if (flags.describe) {
+    printDescription(COMPOSE_DESCRIPTION);
+    return;
+  }
+  const base = process.env["INIT_CWD"] ?? process.cwd();
+  const roots = flags.library !== void 0 && flags.library.length > 0 ? flags.library.map((d) => path41.resolve(base, d)) : [base];
+  if (flags.set === void 0 && (flags.confirmCompositions === true || flags.decline !== void 0 && flags.decline.length > 0)) {
+    fail(flags, ExitCode.InputValidation, {
+      error: "--confirm-compositions/--decline require --set <host> \u2014 a decision needs the host set it decides for",
+      code: "compose-decision-without-set",
+      remediation: "Add --set <host recording-set dir>, or drop the decision flags to list opportunities."
+    });
+  }
+  if (flags.set !== void 0) {
+    runComposeConfirm(flags, path41.resolve(base, flags.set), roots);
+    return;
+  }
+  const index = buildComposeIndex(roots);
+  const edges = composeReport(index);
+  emitData(flags, { sets: index.map((s) => s.dir), edges, note: NOTE }, () => {
+    process.stdout.write(`indexed ${index.length} recording set(s) under ${roots.join(", ")}
+`);
+    if (index.length === 0) {
+      process.stdout.write("no recording sets found \u2014 point --library at a directory that holds recording-set.json sets\n");
+      return;
+    }
+    if (edges.length === 0) {
+      process.stdout.write("no composition edges: no recorded instance references another recorded component (externals stay disclosed in each set's own reports)\n");
+      return;
+    }
+    let lastHost = "";
+    for (const e of edges) {
+      const host = `${path41.basename(e.hostSet)}`;
+      if (host !== lastHost) {
+        process.stdout.write(`
+${host}
+`);
+        lastHost = host;
+      }
+      const partners = e.partners.map((p) => p.displayName).join(" / ") || "\u2014";
+      const pose = e.pose !== void 0 ? ` pose=${e.pose.variantNodeId} (${e.pose.reps.map((r) => `${path41.basename(r.dir)}:${r.slug}`).join(", ")})` : "";
+      process.stdout.write(`  ${e.kind.toUpperCase().padEnd(12)} ${e.hostRep}/${e.instanceId} "${e.instanceName}" \u2192 ${partners}${pose}
+`);
+      for (const d of e.disclosures) process.stdout.write(`    \xB7 ${d}
+`);
+    }
+    process.stdout.write(`
+${NOTE}
+`);
+  });
+}
+function runComposeConfirm(flags, hostSet, roots) {
+  if (!existsSync34(path41.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 (the directory holding recording-set.json)."
+    });
+  }
+  const scanRoots = [.../* @__PURE__ */ new Set([...roots, path41.dirname(hostSet)])];
+  const index = buildComposeIndex(scanRoots);
+  const edges = composeReport(index);
+  const pairs = substitutionPairs(edges, hostSet);
+  const { raw } = readManifestFile(hostSet);
+  const rawStanding = Array.isArray(raw["compositions"]) ? raw["compositions"] : [];
+  const standing = [];
+  for (let i = 0; i < rawStanding.length; i++) {
+    const parsed = CompositionEntrySchema.safeParse(rawStanding[i]);
+    if (!parsed.success) {
+      fail(flags, ExitCode.InputValidation, {
+        error: `compositions[${i}] in ${hostSet}/recording-set.json is not a valid v1 composition entry (${parsed.error.issues[0]?.message ?? "invalid"})`,
+        code: "compositions-entry-invalid",
+        remediation: "The manifest's compositions extension holds human decisions and is provenance-hashed \u2014 repair or remove the malformed entry by hand, then re-run. Nothing was changed."
+      });
+    }
+    standing.push(parsed.data);
+  }
+  const decidedKeys = new Set(standing.map((c) => fromStoredRel(c.partner.key)));
+  const open = pairs.filter((p) => !decidedKeys.has(p.key));
+  const printProposal = () => {
+    for (const s of standing) process.stdout.write(`standing ${s.status.toUpperCase()}: ${s.partner.displayName} [${s.partner.key}] (${s.instances.length} instance(s)) \u2014 asked once, not re-asked
+`);
+    if (open.length === 0) {
+      process.stdout.write(standing.length > 0 ? "no undecided composition pairs for this host\n" : "no id-backed composition pairs found for this host (name-only proposals, if any, are not confirmable \u2014 see compose --list)\n");
+      return;
+    }
+    for (const p of open) {
+      process.stdout.write(`
+PAIR ${p.displayName} [${p.key}]${p.figmaFile !== void 0 ? ` file ${p.figmaFile}` : " \u2014 file identity NOT captured"}
+`);
+      for (const i of p.instances) process.stdout.write(`  ${i.hostRep}/${i.instanceId} \u2192 pose ${i.poseVariantNodeId}
+`);
+      for (const d of p.disclosures) process.stdout.write(`  \xB7 ${d}
+`);
+    }
+  };
+  const deciding = flags.confirmCompositions === true || flags.decline !== void 0 && flags.decline.length > 0;
+  if (open.length === 0 || !deciding) {
+    emitData(flags, { hostSet, openPairs: open, standing, note: "confirmations are human-only; declines persist; name-only proposals are never confirmable" }, printProposal);
+  } else if (!flags.json) {
+    printProposal();
+  }
+  if (open.length === 0) return;
+  if (flags.confirmCompositions !== true && (flags.decline === void 0 || flags.decline.length === 0)) {
+    fail(flags, ExitCode.ConfirmationRequired, {
+      error: "composition pairs require a human decision",
+      code: "compositions-unconfirmed",
+      remediation: `Review the pairs above, then a HUMAN re-runs \`${tendrilCommand(`compose --set ${hostSet} --confirm-compositions`)}\` (confirm all listed) and/or \`--decline <pair-key>\` in their own terminal. Agents: surface this to your operator \u2014 the flag is refused without an interactive terminal, and composing without confirmation never happens.`
+    });
+  }
+  if (process.stdin.isTTY !== true) {
+    fail(flags, ExitCode.ConfirmationRequired, {
+      error: "--confirm-compositions and --decline require an interactive terminal \u2014 this decision is human-only",
+      code: "compositions-confirmation-not-interactive",
+      remediation: `A human runs \`${tendrilCommand(`compose --set ${hostSet} --confirm-compositions`)}\` in their own terminal. Agents: show the proposal to your operator instead of confirming it.`
+    });
+  }
+  const declineKeys = new Set(flags.decline ?? []);
+  for (const k of declineKeys) {
+    if (!open.some((p) => p.key === k)) {
+      fail(flags, ExitCode.InputValidation, {
+        error: `--decline "${k}" names no open pair (open: ${open.map((p) => p.key).join(", ")})`,
+        code: "unknown-composition-pair",
+        remediation: "Spell the pair key exactly as printed in brackets."
+      });
+    }
+  }
+  const entries = open.map((p) => ({
+    v: 1,
+    partner: {
+      key: p.key,
+      displayName: p.displayName,
+      ...p.figmaFile !== void 0 ? { figmaFile: p.figmaFile } : {},
+      // The partner's manifest BYTES, pinned at decision time and
+      // keyed by the same host-relative identity as the pair key —
+      // any partner re-plan/roles/composition write flips it, which
+      // is the staleness signal later slices compare against. (The
+      // full recording-set hash join lands with pin authoring, where
+      // task configs exist.)
+      manifestSha256: Object.fromEntries(
+        p.partnerDirs.map((d) => [path41.relative(hostSet, d), createHash8("sha256").update(readFileSync30(path41.join(d, "recording-set.json"))).digest("hex")])
+      )
+    },
+    instances: p.instances,
+    status: declineKeys.has(p.key) ? "declined" : "confirmed"
+  }));
+  const decided = flags.confirmCompositions === true ? entries : entries.filter((e) => declineKeys.has(e.partner.key));
+  const merged = { ...raw, compositions: [...standing, ...decided] };
+  writeManifest(hostSet, merged);
+  warn(
+    flags,
+    "the host manifest changed \u2014 its bytes are hashed into bundle provenance, so bundles generated from this set before this decision now carry a stale set identity; regenerate to compose (`tendril engine brief` carries the pins)"
+  );
+  emitData(flags, { hostSet, openPairs: open, standing, written: decided, note: "confirmations are human-only; declines persist; name-only proposals are never confirmable" }, () => {
+    for (const e of decided) process.stdout.write(`${e.status.toUpperCase()}: ${e.partner.displayName} [${e.partner.key}] (${e.instances.length} instance(s))
+`);
+  });
+}
+var COMPOSE_DESCRIPTION, NOTE;
+var init_compose2 = __esm({
+  "packages/cli/src/commands/compose.ts"() {
+    "use strict";
+    init_src3();
+    init_src();
+    init_describe();
+    init_invocation();
+    init_output();
+    COMPOSE_DESCRIPTION = {
+      name: "compose",
+      summary: "Composition opportunities across a workspace's recording sets (ADR-013): --list is the read-only discovery surface; --set persists a HUMAN's confirm/decline decisions into the host manifest. Nothing composes yet \u2014 compose-on-generate is a later slice.",
+      args: [],
+      flags: [
+        { flag: "--list", description: "Derive the index and report edges (default)" },
+        { flag: "--library <dir...>", description: "Workspace root(s) to scan for recording sets", default: "current directory" },
+        { flag: "--set <dir>", description: "Confirmation mode: propose this HOST set's id-backed pairs for a human decision (confirmations and declines persist in the host manifest)" },
+        { flag: "--confirm-compositions", description: "HUMAN-ONLY: confirm every open pair printed for --set \u2014 refused without an interactive terminal; agents surface the proposal to their operator" },
+        { flag: "--decline <pair-key...>", description: "HUMAN-ONLY: persistently decline the named pair(s) \u2014 asked once, never re-asked" },
+        { flag: "--json", description: "Machine-readable output" }
+      ],
+      output: {
+        sets: "string[] \u2014 recording sets indexed (--list)",
+        edges: "per-instance edges: kind (substitution | nested | ask | proposal | external), partners, pose (variant node id + per-set rep slugs), disclosures (--list)",
+        openPairs: "with --set: undecided id-backed pairs awaiting a human decision",
+        standing: "with --set: persisted confirmations/declines (asked once)",
+        note: "string \u2014 what this command does NOT do"
+      },
+      exitCodes: { 0: "report printed (an empty one is a report, not an error)", 4: "with --set: open pairs need a human decision, or the flag arrived without an interactive terminal", 3: "with --set: bad host dir or unknown --decline key" },
+      examples: ["tendril compose --list", "tendril compose --list --library ./recordings --json", "tendril compose --set ./recordings/dialog --confirm-compositions"]
+    };
+    NOTE = "Discovery only: these are PROPOSALS under the audited join rule (id evidence decides; name evidence only proposes). Nothing composes yet \u2014 the human confirmation channel and compose-on-generate land in later slices. Substitution-grade edges do NOT assert pixel-neutrality: instance overrides are measured-real and the score-time check is the judge.";
+  }
+});
+
 // packages/cli/src/commands/inspect.ts
 var inspect_exports = {};
 __export(inspect_exports, {
   INSPECT_DESCRIPTION: () => INSPECT_DESCRIPTION,
   runInspect: () => runInspect
 });
-import { existsSync as existsSync32, readFileSync as readFileSync28, writeFileSync as writeFileSync16 } from "node:fs";
-import path39 from "node:path";
+import { existsSync as existsSync35, readFileSync as readFileSync31, writeFileSync as writeFileSync16 } from "node:fs";
+import path42 from "node:path";
 async function runInspect(opts) {
   if (opts.describe) {
     printDescription(INSPECT_DESCRIPTION);
     return;
   }
-  const bundleDir = path39.resolve(opts.bundleDir);
-  const evidenceDir = path39.join(bundleDir, "verify-evidence");
-  const manifestPath2 = path39.join(bundleDir, "component.json");
-  if (!existsSync32(evidenceDir) || !existsSync32(manifestPath2)) {
+  const bundleDir = path42.resolve(opts.bundleDir);
+  const evidenceDir = path42.join(bundleDir, "verify-evidence");
+  const manifestPath2 = path42.join(bundleDir, "component.json");
+  if (!existsSync35(evidenceDir) || !existsSync35(manifestPath2)) {
     fail(opts, ExitCode.InputValidation, {
-      error: `nothing to inspect in ${bundleDir} \u2014 ${existsSync32(manifestPath2) ? "no verify-evidence directory" : "no component.json"}`,
+      error: `nothing to inspect in ${bundleDir} \u2014 ${existsSync35(manifestPath2) ? "no verify-evidence directory" : "no component.json"}`,
       code: "no-evidence",
       remediation: `Run \`${tendrilCommand(`verify ${bundleDir}`)}\` first \u2014 inspect reads the ref/render evidence that run writes.`
     });
   }
-  const { manifest } = readBundleManifest(readFileSync28(manifestPath2, "utf8"));
+  const { manifest } = readBundleManifest(readFileSync31(manifestPath2, "utf8"));
   if (manifest === void 0) {
     fail(opts, ExitCode.InputValidation, {
       error: "component.json did not parse as a bundle manifest",
@@ -12827,8 +13869,8 @@ async function runInspect(opts) {
       remediation: "Re-emit the bundle (score/verify rewrite component.json), then re-run inspect."
     });
   }
-  const setDir = path39.resolve(opts.set ?? manifest.provenance.recordingSet.path);
-  const reps = Object.keys(manifest.propAdapter).filter((rep) => existsSync32(path39.join(evidenceDir, `${rep}-ref.png`)) && existsSync32(path39.join(evidenceDir, `${rep}-render.png`)));
+  const setDir = path42.resolve(opts.set ?? manifest.provenance.recordingSet.path);
+  const reps = Object.keys(manifest.propAdapter).filter((rep) => existsSync35(path42.join(evidenceDir, `${rep}-ref.png`)) && existsSync35(path42.join(evidenceDir, `${rep}-render.png`)));
   if (reps.length === 0) {
     fail(opts, ExitCode.InputValidation, {
       error: "verify-evidence holds no ref/render pairs for this bundle's configs",
@@ -12839,15 +13881,15 @@ async function runInspect(opts) {
   let crops = 0;
   const sections = [];
   for (const rep of reps) {
-    const ref = new Uint8Array(readFileSync28(path39.join(evidenceDir, `${rep}-ref.png`)));
-    const render = new Uint8Array(readFileSync28(path39.join(evidenceDir, `${rep}-render.png`)));
+    const ref = new Uint8Array(readFileSync31(path42.join(evidenceDir, `${rep}-ref.png`)));
+    const render = new Uint8Array(readFileSync31(path42.join(evidenceDir, `${rep}-render.png`)));
     const nodes = smallSemanticNodes(setDir, rep, opts.maxArea ?? 1024).slice(0, 12);
     const cells = [];
     for (const [i, n] of nodes.entries()) {
       const rect = { x: n.x, y: n.y, w: n.w, h: n.h };
       try {
-        writeFileSync16(path39.join(evidenceDir, `${rep}-inspect-${i}-ref.png`), zoomCrop(ref, rect));
-        writeFileSync16(path39.join(evidenceDir, `${rep}-inspect-${i}-render.png`), zoomCrop(render, rect));
+        writeFileSync16(path42.join(evidenceDir, `${rep}-inspect-${i}-ref.png`), zoomCrop(ref, rect));
+        writeFileSync16(path42.join(evidenceDir, `${rep}-inspect-${i}-render.png`), zoomCrop(render, rect));
       } catch {
         continue;
       }
@@ -12860,7 +13902,7 @@ async function runInspect(opts) {
       `<section><h2>${esc(rep)}</h2><div class="full"><span><em>recorded</em><img src="./${rep}-ref.png"></span><span><em>rendered</em><img src="./${rep}-render.png"></span><span><em>diff</em><img src="./${rep}-diff.png"></span></div>` + (cells.length > 0 ? `<div class="grid">${cells.join("")}</div>` : `<p class="none">no small recorded nodes in this config's sweep</p>`) + `</section>`
     );
   }
-  const sheet = path39.join(evidenceDir, "inspect.html");
+  const sheet = path42.join(evidenceDir, "inspect.html");
   writeFileSync16(
     sheet,
     `<!doctype html><meta charset="utf-8"><title>${esc(manifest.name)} \u2014 tendril inspect</title><style>
@@ -12938,17 +13980,17 @@ __export(generate_recorded_exports, {
   runGenerateRecorded: () => runGenerateRecorded
 });
 import { confirm as confirm3, isCancel as isCancel3 } from "@clack/prompts";
-import { existsSync as existsSync33, readFileSync as readFileSync29 } from "node:fs";
-import path40 from "node:path";
+import { existsSync as existsSync36, readFileSync as readFileSync32 } from "node:fs";
+import path43 from "node:path";
 async function runGenerateRecorded(opts) {
   const callerCwd = process.env["INIT_CWD"] ?? process.cwd();
-  const outDirAbs = path40.resolve(callerCwd, opts.out);
-  const recordedAsPath = path40.resolve(callerCwd, opts.recorded);
+  const outDirAbs = path43.resolve(callerCwd, opts.out);
+  const recordedAsPath = path43.resolve(callerCwd, opts.recorded);
   let task;
   let taskName;
   let authoredApi;
   let composition;
-  const isSet = existsSync33(path40.join(recordedAsPath, "recording-set.json"));
+  const isSet = existsSync36(path43.join(recordedAsPath, "recording-set.json"));
   const registry = TASKS[opts.recorded];
   if (registry !== void 0 && !isSet) {
     task = registry;
@@ -12957,7 +13999,7 @@ async function runGenerateRecorded(opts) {
     try {
       const authored = authorTaskFromSet(recordedAsPath);
       task = authored.task;
-      taskName = path40.basename(recordedAsPath);
+      taskName = path43.basename(recordedAsPath);
       authoredApi = authored.api;
       const roles = RolesSchema.safeParse(loadManifest(recordedAsPath).roles);
       if (roles.success) composition = roles.data;
@@ -12991,7 +14033,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) => !existsSync33(path40.join(task.set, c.rep, "get_screenshot.json")) || !existsSync33(path40.join(task.set, c.rep, "get_metadata.json")) || !existsSync33(path40.join(task.set, c.rep, "get_design_context.json"))
+    (c) => !existsSync36(path43.join(task.set, c.rep, "get_screenshot.json")) || !existsSync36(path43.join(task.set, c.rep, "get_metadata.json")) || !existsSync36(path43.join(task.set, c.rep, "get_design_context.json"))
   );
   if (missing.length > 0) {
     fail(opts, ExitCode.RecordingIncomplete, {
@@ -13061,8 +14103,8 @@ async function runGenerateRecorded(opts) {
 ` : `${line}
 `);
   if (opts.dryRun) {
-    emitData(opts, { dryRun: true, task: taskName, model: modelId, consent, wouldWrite: path40.join(outDirAbs, taskName) }, () => {
-      process.stdout.write(`dry-run: nothing sent, nothing written (would write ${path40.join(outDirAbs, taskName)})
+    emitData(opts, { dryRun: true, task: taskName, model: modelId, consent, wouldWrite: path43.join(outDirAbs, taskName) }, () => {
+      process.stdout.write(`dry-run: nothing sent, nothing written (would write ${path43.join(outDirAbs, taskName)})
 `);
     });
     return;
@@ -13085,10 +14127,10 @@ async function runGenerateRecorded(opts) {
       });
     }
   }
-  const bundleDir = path40.join(outDirAbs, taskName);
-  if (existsSync33(path40.join(bundleDir, "component.json"))) {
+  const bundleDir = path43.join(outDirAbs, taskName);
+  if (existsSync36(path43.join(bundleDir, "component.json"))) {
     try {
-      const prior = readBundleManifest(readFileSync29(path40.join(bundleDir, "component.json"), "utf8")).manifest;
+      const prior = readBundleManifest(readFileSync32(path43.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`,
@@ -13254,7 +14296,7 @@ init_invocation();
 init_output();
 import { intro, isCancel, outro, password } from "@clack/prompts";
 import fs from "node:fs";
-import path25 from "node:path";
+import path26 from "node:path";
 var INIT_DESCRIPTION = {
   name: "init",
   summary: "Configure Figma and OpenRouter credentials in .env (idempotent).",
@@ -13291,7 +14333,7 @@ async function runInit(flags) {
     printDescription(INIT_DESCRIPTION);
     return;
   }
-  const envPath = path25.resolve(process.cwd(), ".env");
+  const envPath = path26.resolve(process.cwd(), ".env");
   const existing = fs.existsSync(envPath) ? parseEnv(fs.readFileSync(envPath, "utf8")) : /* @__PURE__ */ new Map();
   let figmaToken = flags.figmaToken ?? existing.get(ENV_KEYS.figma);
   let openrouterKey = flags.openrouterKey ?? existing.get(ENV_KEYS.openrouter);
@@ -13312,7 +14354,7 @@ async function runInit(flags) {
   next.set(ENV_KEYS.figma, figmaToken);
   next.set(ENV_KEYS.openrouter, openrouterKey);
   const changed = existing.get(ENV_KEYS.figma) !== next.get(ENV_KEYS.figma) || existing.get(ENV_KEYS.openrouter) !== next.get(ENV_KEYS.openrouter);
-  const gitignorePath = path25.resolve(process.cwd(), ".gitignore");
+  const gitignorePath = path26.resolve(process.cwd(), ".gitignore");
   const gitignore = fs.existsSync(gitignorePath) ? fs.readFileSync(gitignorePath, "utf8") : "";
   const gitignoreCoversEnv = gitignore.split("\n").some((line) => [".env", ".env", ".env*"].includes(line.trim()));
   if (flags.dryRun) {
@@ -13368,14 +14410,14 @@ init_invocation();
 init_output();
 init_entitlement();
 import { confirm as confirm2, isCancel as isCancel2 } from "@clack/prompts";
-import { readFileSync as readFileSync16, readdirSync as readdirSync5, existsSync as existsSync20 } from "node:fs";
+import { readFileSync as readFileSync17, readdirSync as readdirSync7, existsSync as existsSync21 } from "node:fs";
 
 // packages/cli/src/pipeline.ts
 init_src2();
 init_src4();
 init_src6();
 import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync8 } from "node:fs";
-import path26 from "node:path";
+import path27 from "node:path";
 
 // packages/cli/src/assets-module.ts
 init_src();
@@ -13711,7 +14753,7 @@ async function runGenerationPipeline(input) {
   });
   const written = [];
   if (!input.dryRun) {
-    const dir = path26.resolve(input.outDir, semantics.componentName);
+    const dir = path27.resolve(input.outDir, semantics.componentName);
     mkdirSync5(dir, { recursive: true });
     const files = {
       // Bundle-local tokens: THE emission the component's CSS resolves
@@ -13735,13 +14777,13 @@ async function runGenerationPipeline(input) {
 `
     };
     for (const [name, content] of Object.entries(files)) {
-      const filePath = path26.join(dir, name);
+      const filePath = path27.join(dir, name);
       writeFileSync8(filePath, content);
       written.push(filePath);
     }
     for (const artifact of emitTokenArtifacts(input.mapping)) {
-      const filePath = path26.resolve(input.outDir, artifact.path);
-      mkdirSync5(path26.dirname(filePath), { recursive: true });
+      const filePath = path27.resolve(input.outDir, artifact.path);
+      mkdirSync5(path27.dirname(filePath), { recursive: true });
       writeFileSync8(filePath, artifact.content);
       written.push(filePath);
     }
@@ -13800,7 +14842,7 @@ var GENERATE_DESCRIPTION = {
 function resolveProvidedSource(flags, contextFile) {
   let raw;
   try {
-    raw = readFileSync16(contextFile, "utf8");
+    raw = readFileSync17(contextFile, "utf8");
   } catch {
     fail(flags, ExitCode.InputValidation, {
       error: `Cannot read context file "${contextFile}".`,
@@ -13920,11 +14962,11 @@ token mapping (${mapping.flat.length} variables):
   let initialCode;
   let initialSemantics;
   try {
-    if (existsSync20(flags.out)) {
-      for (const entry of readdirSync5(flags.out)) {
+    if (existsSync21(flags.out)) {
+      for (const entry of readdirSync7(flags.out)) {
         const cjPath = `${flags.out}/${entry}/component.json`;
-        if (!existsSync20(cjPath)) continue;
-        const cj = JSON.parse(readFileSync16(cjPath, "utf8"));
+        if (!existsSync21(cjPath)) continue;
+        const cj = JSON.parse(readFileSync17(cjPath, "utf8"));
         if (cj.name !== void 0 && Array.isArray(cj.props)) {
           previousApi = JSON.stringify({
             componentName: cj.name,
@@ -13932,14 +14974,14 @@ token mapping (${mapping.flat.length} variables):
           });
           const tsxPath = `${flags.out}/${entry}/${cj.name}.tsx`;
           const cssPath = `${flags.out}/${entry}/${cj.name}.css`;
-          if (flags.refine && existsSync20(tsxPath) && existsSync20(cssPath)) {
+          if (flags.refine && existsSync21(tsxPath) && existsSync21(cssPath)) {
             initialCode = {
-              tsx: readFileSync16(tsxPath, "utf8"),
-              css: readFileSync16(cssPath, "utf8")
+              tsx: readFileSync17(tsxPath, "utf8"),
+              css: readFileSync17(cssPath, "utf8")
             };
             const semPath = `${flags.out}/${entry}/semantics.json`;
-            if (existsSync20(semPath)) {
-              initialSemantics = JSON.parse(readFileSync16(semPath, "utf8"));
+            if (existsSync21(semPath)) {
+              initialSemantics = JSON.parse(readFileSync17(semPath, "utf8"));
             }
           }
           break;
@@ -14246,7 +15288,7 @@ function buildProgram() {
     runFontsRequired2({ ...flags, families, cacheDir: cmd.opts()["cache"] ?? DEFAULT_FONT_CACHE });
   });
   const engine = program.command("engine").description("Agent-harness protocol (ADR-012): the host agent proposes; these commands are the CLI-owned brief and oracle.");
-  engine.command("brief").argument("<taskOrSet>", "reference task name or recording-set directory").option("--bar <bar>", "target bar: pass (0.95) or cert (0.97)", "pass").option("--out <file>", "payload file path (default tendril-out/<name>-brief.md)").option("--model <id>", "declared proposer model (the MCP surface requires it; score refuses without one)").action(async (taskOrSet, _o, cmd) => {
+  engine.command("brief").argument("<taskOrSet>", "reference task name or recording-set directory").option("--bar <bar>", "target bar: pass (0.95) or cert (0.97)", "pass").option("--out <file>", "payload file path (default tendril-out/<name>-brief.md)").option("--model <id>", "declared proposer model (the MCP surface requires it; score refuses without one)").option("--library <dir>", "workspace root holding confirmed partners generated bundles (ADR-013 composed pins; default: current directory)").action(async (taskOrSet, _o, cmd) => {
     const flags = globalFlags(cmd.parent.parent);
     const local = cmd.opts();
     const { runEngineBrief: runEngineBrief2 } = await Promise.resolve().then(() => (init_engine2(), engine_exports));
@@ -14255,10 +15297,11 @@ function buildProgram() {
       taskOrSet,
       bar: local["bar"] === "cert" ? "cert" : "pass",
       ...local["out"] !== void 0 ? { out: local["out"] } : {},
-      ...local["model"] !== void 0 ? { model: local["model"] } : {}
+      ...local["model"] !== void 0 ? { model: local["model"] } : {},
+      ...local["library"] !== void 0 ? { library: local["library"] } : {}
     });
   });
-  engine.command("score").argument("<taskOrSet>", "reference task name or recording-set directory").argument("<candidateDir>", "directory containing the proposed bundle files").option("--bar <bar>", "target bar: pass (0.95) or cert (0.97)", "pass").option("--host <name>", "self-reported host identity (recorded in provenance, labeled self-reported)").requiredOption("--model <id>", "proposer model, self-reported \u2014 required; a score without a declared model is not accepted").option("--rebind", "explicitly re-bind an already-bound bundle to a different recording set (refused otherwise \u2014 rebinding rewrites the bundle's verification identity)").action(async (taskOrSet, candidateDir, _o, cmd) => {
+  engine.command("score").argument("<taskOrSet>", "reference task name or recording-set directory").argument("<candidateDir>", "directory containing the proposed bundle files").option("--bar <bar>", "target bar: pass (0.95) or cert (0.97)", "pass").option("--host <name>", "self-reported host identity (recorded in provenance, labeled self-reported)").requiredOption("--model <id>", "proposer model, self-reported \u2014 required; a score without a declared model is not accepted").option("--rebind", "explicitly re-bind an already-bound bundle to a different recording set (refused otherwise \u2014 rebinding rewrites the bundle's verification identity)").option("--library <dir>", "workspace root holding confirmed partners generated bundles (ADR-013 composed pins; default: current directory)").action(async (taskOrSet, candidateDir, _o, cmd) => {
     const flags = globalFlags(cmd.parent.parent);
     const local = cmd.opts();
     const { runEngineScore: runEngineScore2 } = await Promise.resolve().then(() => (init_engine2(), engine_exports));
@@ -14269,7 +15312,8 @@ function buildProgram() {
       bar: local["bar"] === "cert" ? "cert" : "pass",
       ...local["host"] !== void 0 ? { host: local["host"] } : {},
       model: local["model"],
-      rebind: local["rebind"]
+      rebind: local["rebind"],
+      ...local["library"] !== void 0 ? { library: local["library"] } : {}
     });
   });
   program.command("codeconnect").description("Emit a Figma Code Connect template (.figma.ts) for a certified bundle \u2014 every variant\u2192prop mapping from recorded truth, stamped with the trust statement. Publishing stays yours (figma connect publish; Org/Enterprise plan).").argument("<bundleDir>", "bundle directory (must carry component.json)").requiredOption("--figma-url <url>", "figma.com /design/ URL of the COMPONENT SET (Copy link to selection)").option("--set <dir>", "recording set override (default: the bundle's provenance path)").option("--out <file>", "output file (default: <bundle>/<Component>.figma.ts)").action(async (bundleDir, _o, cmd) => {
@@ -14297,6 +15341,19 @@ function buildProgram() {
       ...local["tendrilPrefix"] !== void 0 ? { tendrilPrefix: local["tendrilPrefix"] } : {}
     });
   });
+  program.command("compose").description("Composition opportunities across a workspace's recording sets (ADR-013): --list discovers (read-only); --set persists a HUMAN's confirm/decline decisions into the host manifest. Nothing composes yet.").option("--list", "derive the index and report edges (default)").option("--library <dir...>", "workspace root(s) to scan for recording sets (default: current directory)").option("--set <dir>", "confirmation mode: propose this HOST set's id-backed pairs for a human decision").option("--confirm-compositions", "HUMAN-ONLY: confirm every open pair printed for --set (refused without an interactive terminal; agents surface the proposal instead)").option("--decline <pair-key...>", "HUMAN-ONLY: persistently decline the named pair(s) \u2014 asked once, never re-asked").action(async (_o, cmd) => {
+    const flags = globalFlags(cmd.parent);
+    const local = cmd.opts();
+    const { runCompose: runCompose2 } = await Promise.resolve().then(() => (init_compose2(), compose_exports));
+    runCompose2({
+      ...flags,
+      ...local["list"] !== void 0 ? { list: local["list"] } : {},
+      ...local["library"] !== void 0 ? { library: local["library"] } : {},
+      ...local["set"] !== void 0 ? { set: local["set"] } : {},
+      ...local["confirmCompositions"] !== void 0 ? { confirmCompositions: local["confirmCompositions"] } : {},
+      ...local["decline"] !== void 0 ? { decline: local["decline"] } : {}
+    });
+  });
   program.command("inspect").description("Build an eye-verifiable detail sheet from verify evidence: magnified recorded-vs-rendered crops of every small recorded node (icons, controls, marks) plus full-frame triples, in one static HTML page.").argument("<bundleDir>", "bundle directory with component.json and verify-evidence").option("--set <dir>", "recording set override (default: the bundle's provenance path)").option("--max-area <px2>", "node area ceiling for the detail sweep", "1024").action(async (bundleDir, _o, cmd) => {
     const flags = globalFlags(cmd.parent);
     const local = cmd.opts();
@@ -14308,7 +15365,7 @@ function buildProgram() {
       ...local["maxArea"] !== void 0 ? { maxArea: Number(local["maxArea"]) } : {}
     });
   });
-  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").action(async (bundleDir, _opts, cmd) => {
+  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)").action(async (bundleDir, _opts, cmd) => {
     const flags = globalFlags(cmd);
     const local = cmd.opts();
     const bar = local["bar"] === "cert" ? "cert" : "pass";
@@ -14318,6 +15375,7 @@ function buildProgram() {
       bundleDir,
       ...local["task"] !== void 0 ? { task: local["task"] } : {},
       ...local["set"] !== void 0 ? { set: local["set"] } : {},
+      ...local["library"] !== void 0 ? { library: local["library"] } : {},
       bar
     });
   });