@tendrilapp/cli 0.1.53 → 0.1.54

package/dist/SKILL.md

@@ -253,7 +253,13 @@ Batch runs (several components in one session):
 5. COMPOSITION: read the status output's `composition` block. If it
    lists unconfirmed partner pairs, this recording references OTHER
    recorded components (a segmented control built from a recorded
-   Control, a dialog holding a recorded Button). Order matters:
+   Control, a dialog holding a recorded Button). A pair the human
+   ALREADY confirmed can legitimately re-open as a GROWTH ask
+   (`growsConfirmed: true`): new evidence derived MORE instances of
+   the same pairing — say so as an addition, never as a contradiction
+   of the settled decision; confirming adds the new instances, the
+   standing confirmation is untouched, and growth asks cannot be
+   declined (leave them unconfirmed and they simply stay local). Order matters:
    generate the PARTNER bundle first, then put the pairing decision in
    front of the human — it is human-only on either channel, and you
    can never make it. CLICK PATH (lead with this): `tendril_compose`
@@ -388,6 +394,13 @@ Batch runs (several components in one session):
    genuinely headless runs; it cannot tell "nobody is there" from "the
    harness said nobody is there", so it must at least say what it did,
    loudly and first.)
+   PRESENCE PROOF OVERRIDES THE NON-INTERACTIVE BRANCH: a browser
+   approval decided mid-run — a compose card approved, a publish
+   card clicked — is a human at the keyboard, whatever the harness
+   said. From the moment one lands, ask the consent gates that
+   remain instead of auto-resolving them (measured, 2026-08-30: a
+   run auto-resolved the model pick for its THIRD generation while
+   the user was demonstrably present, having just clicked Approve).
    Weak models produce honest sub-bar reports, never false passes.
 6. Tell the user roughly what a run costs them: organism-scale
    components have measured 0.3–0.7M tokens of their plan.
@@ -527,6 +540,14 @@ live at <URL>" (or "done — waiting for your Approve at <link>, as
 <account>"), before scores, caveats and file lists. The user should
 never have to ask where their component is.
 
+And invite the ONE check only the user can run: right after the
+done-line, ask them to open the live page and say whether the demo
+renders. You cannot execute the published page — a browser can, and
+a served-page defect is invisible to every check this pipeline runs
+(measured, 2026-08-30: two publishes reported "done — live" while
+both live demos showed an error banner nobody had seen). One line,
+no urging: "open it and tell me if anything looks off."
+
 A green verify may also print COMPOSE lines: other recorded components
 that embed the one just verified. Relay them after the done-line as
 DISCLOSURES (zero questions — the confirm decision is human-only, in

package/dist/tendril-mcp.js

@@ -125,9 +125,18 @@ var TOOLS = [
     description: "Publish a VERIFIED bundle to the user's portal \u2014 phase one of the browser-approved publish. Re-publishing an already-published component completes in one call. A component's FIRST publish is a human-only decision the portal enforces: this call requests the approval and returns the approve-page link \u2014 RELAY IT to the user verbatim, along with which account the result says to be signed in as (they click Approve in the browser; approving includes accepting the design system's publishing terms, which is their decision to make, never yours to urge). Then call tendril_publish_wait to finish. You cannot approve this yourself: the portal only accepts the decision from their signed-in browser, never from this machine's token. Requires a green verify (the CLI refuses a declined run) and a portal session (tendril_login).",
     schema: z.object({
       bundleDir: str("bundle directory (verified \u2014 carries component.json and verify-evidence)"),
-      portal: optStr("portal origin override for self-hosted portals (defaults to the stored session's portal)")
+      portal: optStr("portal origin override for self-hosted portals (defaults to the stored session's portal)"),
+      designSystemName: optStr(
+        "first publish only: a PROPOSED display name for the design system, prefilled on the approve card where the human names or picks it \u2014 pass the design's human name when you know it (the Figma file's title, the design system the user named); without a proposal the card prefills the raw Figma file key, and a plain Approve makes that key the permanent name"
+      )
     }),
-    argv: (i) => ["publish", i["bundleDir"], "--approve-start", ...typeof i["portal"] === "string" ? ["--to", i["portal"]] : []]
+    argv: (i) => [
+      "publish",
+      i["bundleDir"],
+      "--approve-start",
+      ...typeof i["designSystemName"] === "string" ? ["--design-system-name", i["designSystemName"]] : [],
+      ...typeof i["portal"] === "string" ? ["--to", i["portal"]] : []
+    ]
   },
   {
     name: "tendril_publish_wait",

package/dist/tendril.js

@@ -1940,18 +1940,22 @@ function sameComponent(a, b) {
   for (const id of a.variantNodeIds) if (b.variantNodeIds.has(id)) return true;
   return false;
 }
-function emissionTails(setDir, repSlug) {
+function emissionText(setDir, repSlug) {
   const file = path4.join(setDir, repSlug, "get_design_context.json");
-  if (!existsSync4(file)) return /* @__PURE__ */ new Map();
+  if (!existsSync4(file)) return void 0;
   let text;
   try {
     text = envelopeTextContent(JSON.parse(readFileSync3(file, "utf8")));
   } catch {
-    return /* @__PURE__ */ new Map();
+    return void 0;
   }
   const cut = text.search(FOOTER);
-  if (cut !== -1) text = text.slice(0, cut);
+  return cut === -1 ? text : text.slice(0, cut);
+}
+function emissionTails(setDir, repSlug) {
+  const text = emissionText(setDir, repSlug);
   const byHead = /* @__PURE__ */ new Map();
+  if (text === void 0) return byHead;
   for (const m of text.matchAll(/data-node-id="I([^"]+)"/g)) {
     const segs = m[1].split(";");
     const head = segs[0];
@@ -1964,6 +1968,171 @@ function emissionTails(setDir, repSlug) {
   }
   return byHead;
 }
+function declarationEnd(text, afterOpenParen) {
+  let i = afterOpenParen;
+  let parens = 1;
+  for (; i < text.length && parens > 0; i++) {
+    const ch = text[i];
+    if (ch === '"') {
+      i = text.indexOf('"', i + 1);
+      if (i === -1) return text.length;
+      continue;
+    }
+    if (ch === "(") parens++;
+    else if (ch === ")") parens--;
+  }
+  let body = text.indexOf("{", i);
+  if (body === -1) return text.length;
+  let depth = 0;
+  for (; body < text.length; body++) {
+    const ch = text[body];
+    if (ch === '"') {
+      body = text.indexOf('"', body + 1);
+      if (body === -1) return text.length;
+      continue;
+    }
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) return body + 1;
+    }
+  }
+  return text.length;
+}
+function hoistedCallAnalysis(text, root, hostIds) {
+  const matches = [...text.matchAll(/function\s+([A-Za-z_$][\w$]*)\s*\(/g)];
+  const decls = matches.map((d) => ({
+    name: d[1],
+    start: d.index ?? 0,
+    bodyStart: (d.index ?? 0) + d[0].length,
+    end: declarationEnd(text, (d.index ?? 0) + d[0].length)
+  }));
+  const names = decls.map((d) => d.name);
+  const dup = names.find((n, i) => names.indexOf(n) !== i);
+  if (dup !== void 0) return { refusal: `hoisted function name ${dup} is not unique` };
+  const rootElementId = (d) => /return\s*\(?\s*<[^>]*?\bdata-node-id="([^"]+)"/.exec(text.slice(d.bodyStart, d.end))?.[1];
+  const owner = decls.find((d) => rootElementId(d) === root);
+  if (owner === void 0) return { refusal: "the pose root is not any hoisted function's ROOT element" };
+  if (/\bid=\{/.test(text.slice(owner.start, owner.end))) {
+    return { refusal: "the hoisted function is multi-variant (conditional element ids) \u2014 one function does not mean one pose" };
+  }
+  const byName = new Map(decls.map((d) => [d.name, d]));
+  let top = "";
+  let cursor = 0;
+  for (const d of decls) {
+    if (d.start > cursor) top += text.slice(cursor, d.start);
+    cursor = Math.max(cursor, d.end);
+  }
+  top += text.slice(cursor);
+  const inDegree = new Map(decls.map((d) => [d.name, 0]));
+  const callSources = [top, ...decls.map((d) => text.slice(d.bodyStart, d.end))];
+  for (const source of callSources) {
+    for (const m of source.matchAll(/<([A-Z][\w$]*)(?![\w$])/g)) {
+      if (inDegree.has(m[1])) inDegree.set(m[1], inDegree.get(m[1]) + 1);
+    }
+  }
+  const regions = [top];
+  const entered = /* @__PURE__ */ new Set();
+  for (const d of decls) {
+    const rid = rootElementId(d);
+    if (inDegree.get(d.name) === 0 && rid !== void 0 && hostIds.has(rid)) {
+      entered.add(d.name);
+      regions.push(text.slice(d.bodyStart, d.end));
+    }
+  }
+  for (let i = 0; i < regions.length; i++) {
+    for (const m of regions[i].matchAll(/<([A-Z][\w$]*)(?![\w$])/g)) {
+      const d = byName.get(m[1]);
+      if (d !== void 0 && !entered.has(d.name)) {
+        entered.add(d.name);
+        regions.push(text.slice(d.bodyStart, d.end));
+      }
+    }
+  }
+  let count = 0;
+  for (const region of regions) {
+    for (const c of region.matchAll(new RegExp(`<${owner.name}(?![\\w$])([^>]*?)/?>`, "g"))) {
+      const props = c[1].replace(/\/$/, "").trim();
+      if (props !== "" && !/^className=("[^"]*"|\{[^}]*\})$/.test(props)) {
+        return { refusal: `a call site passes props beyond className \u2014 it may render a different pose or content (<${owner.name} ${props.slice(0, 48)}\u2026>)` };
+      }
+      count++;
+    }
+  }
+  return { calls: count };
+}
+function hoistedRecoveryFor(host, slug, index, residuals) {
+  if (residuals.length === 0) return {};
+  const text = emissionText(host.dir, slug);
+  if (text === void 0) return {};
+  const foreign = /* @__PURE__ */ new Set();
+  for (const m of text.matchAll(/data-node-id="([^"]+)"/g)) {
+    if (!m[1].startsWith("I") && !host.ownIds.has(m[1])) foreign.add(m[1]);
+  }
+  const hits = [];
+  const libraryRefused = [];
+  for (const c of index) {
+    if (c.dir === host.dir || sameComponent(c, host)) continue;
+    const roots = [...foreign].filter((id) => c.variantNodeIds.has(id));
+    if (roots.length === 0) continue;
+    if (host.figmaFile !== void 0 && c.figmaFile !== void 0 && c.figmaFile !== host.figmaFile) {
+      libraryRefused.push(c);
+      continue;
+    }
+    hits.push({ entry: c, roots });
+  }
+  if (hits.length === 0) {
+    return libraryRefused.length === 0 ? {} : {
+      note: `LIBRARY-EDGE (not auto-joined): a hoisted pose root names ${kitLabel(libraryRefused[0])} recorded from a DIFFERENT file \u2014 the same-file rule refuses; the future cross-file ADR owns this class`
+    };
+  }
+  const groups = [];
+  for (const h of hits) {
+    const g = groups.find((grp) => grp.members.some((m) => sameComponent(m, h.entry)));
+    if (g) {
+      g.members.push(h.entry);
+      for (const r of h.roots) g.roots.add(r);
+    } else groups.push({ members: [h.entry], roots: new Set(h.roots) });
+  }
+  const label = (g) => `${g.members[0].displayName} (${[...g.roots].join(", ")})`;
+  if (groups.length > 1 || groups[0].roots.size > 1) {
+    return {
+      note: `HOISTED CONTENT, NOT FORCED: this pose's emission carries hoisted partner pose root(s) ${groups.map(label).join(" / ")} without per-instance node ids \u2014 ${groups.length > 1 ? "multiple components" : "multiple poses"} are hoisted, so per-instance attribution is not forced and no join is proposed from it (a human decision channel for the multi-root shape is future work)`
+    };
+  }
+  const group = groups[0];
+  const root = [...group.roots][0];
+  const identityNames = new Set(group.members.map((m) => norm(m.figmaComponentName ?? m.displayName)));
+  if (identityNames.size > 1) {
+    return {
+      note: `HOISTED CONTENT, NOT FORCED: pose root ${root} joins recordings whose identity names DISAGREE (${group.members.map((m) => m.figmaComponentName ?? m.displayName).join(" / ")}) \u2014 no name agreement is derivable, no join is proposed`
+    };
+  }
+  const identityName = group.members[0].figmaComponentName ?? group.members[0].displayName;
+  const disagreeing = residuals.filter((r) => norm(r.name) !== norm(identityName));
+  if (disagreeing.length > 0) {
+    return {
+      note: `HOISTED CONTENT, NOT FORCED: pose root ${root} of ${kitLabel(group.members[0])} is hoisted here, but ${String(disagreeing.length)} residual instance(s) carry a different name (${disagreeing.map((r) => `"${r.name}"`).join(", ")}) \u2014 attribution is not forced, no join is proposed`
+    };
+  }
+  const analysis = hoistedCallAnalysis(text, root, host.ownIds);
+  if (analysis.calls === void 0 || analysis.calls !== residuals.length) {
+    return {
+      note: `HOISTED CONTENT, NOT FORCED: pose root ${root} of ${kitLabel(group.members[0])} is hoisted here, but the assignment is not forced (${analysis.refusal ?? `${String(analysis.calls)} call site(s) in this pose's root region vs ${String(residuals.length)} residual instance(s)`}) \u2014 no join is proposed from it`
+    };
+  }
+  const disclosures = [];
+  const uncaptured = [host.figmaFile === void 0 ? "the host set" : void 0, ...group.members.map((m) => m.figmaFile === void 0 ? path4.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`);
+  }
+  if (group.members.every((m) => m.figmaComponentName === void 0)) {
+    disclosures.push(`identity name not captured on any partner recording \u2014 the name agreement rests on plan-time display names`);
+  }
+  return { forced: { group: group.members, root, identityName, disclosures, instanceIds: new Set(residuals.map((r) => r.id)) } };
+}
 function bindingsFromEntry(entry) {
   const out = /* @__PURE__ */ new Map();
   const components = entry?.components ?? {};
@@ -2049,6 +2218,10 @@ function composeReport(index) {
       const tailsByHead = emissionTails(host.dir, slug);
       const cidByInstance = restInstancePoses(host.dir, slug, variantNodeId);
       const repIsMcpRecorded = !resolveRepEnvelopePathIn(path4.join(host.dir, slug), "metadata").endsWith(REST_METADATA_FILE);
+      const residuals = instances.filter(
+        (i) => i.visible && (tailsByHead.get(i.id)?.size ?? 0) === 0 && cidByInstance.bindings.get(i.id)?.componentId === void 0
+      );
+      const hoisted = hoistedRecoveryFor(host, slug, index, residuals);
       for (const inst of instances) {
         if (visibleEver.get(inst.id) !== true) {
           edges.push({
@@ -2124,6 +2297,34 @@ function composeReport(index) {
           return norm(identityName) === norm(inst.name);
         });
         if (eligible.length === 0) {
+          if (hoisted.forced !== void 0 && hoisted.forced.instanceIds.has(inst.id)) {
+            const f = hoisted.forced;
+            edges.push({
+              hostSet: host.dir,
+              hostRep: slug,
+              instanceId: inst.id,
+              instanceName: inst.name,
+              kind: "substitution",
+              partners: f.group.map((p) => ({ dir: p.dir, displayName: p.displayName, ...p.figmaFile !== void 0 ? { figmaFile: p.figmaFile } : {} })),
+              pose: {
+                variantNodeId: f.root,
+                reps: f.group.filter((m) => m.repSlugByVariantNode.has(f.root)).map((m) => ({ dir: m.dir, slug: m.repSlugByVariantNode.get(f.root) }))
+              },
+              disclosures: [
+                ...disclosures,
+                ...f.disclosures,
+                // Plain-language lead, then the technical basis — the
+                // human confirm gate is the one backstop in front of a
+                // wrong forced join, so the sentence must be readable
+                // by the designer who decides (audit, frame lens).
+                `substitution-grade (HOISTED-ROOT RECOVERY: this pose renders the partner through a deduplicated helper Figma emitted without per-instance node ids, and the evidence pins it to exactly one recorded partner pose \u2014 pose node id ${f.root} on the helper's root, prop-free call sites in this pose equal to the unattributed instances, every name in agreement); pixel-neutrality is NOT asserted here \u2014 instance overrides are measured real, and a per-region check is still future work (whole-frame pixels remain the evidence for composed regions)`
+              ]
+            });
+            continue;
+          }
+          if (hoisted.note !== void 0 && residuals.some((r) => r.id === inst.id)) {
+            disclosures.push(hoisted.note);
+          }
           if (nameProps.length > 0) {
             edges.push({
               hostSet: host.dir,
@@ -6878,6 +7079,17 @@ function classifyBundleSurface(files, opts) {
       unknown.push(path66);
       continue;
     }
+    if (path66.startsWith("composed/")) {
+      const rest = path66.slice("composed/".length);
+      const slash = rest.indexOf("/");
+      const partner = slash === -1 ? "" : rest.slice(0, slash);
+      const fname = slash === -1 ? "" : rest.slice(slash + 1);
+      const partnerOk = /^[A-Za-z0-9][A-Za-z0-9._ -]*$/.test(partner) && !partner.includes("..");
+      const fileOk = fname === "styles.css" || fname === "tokens.css" || fname === "fonts.css" || /^[A-Za-z0-9][A-Za-z0-9._ -]*\.tsx$/.test(fname) && !fname.includes("..");
+      if (partnerOk && fileOk && !fname.includes("/")) published.push({ path: path66, role: "composed" });
+      else unknown.push(path66);
+      continue;
+    }
     const name = inEvidence ? path66.slice(EVIDENCE_DIR.length + 1) : path66;
     if (name.includes("/")) {
       unknown.push(path66);
@@ -6947,6 +7159,13 @@ var init_published_surface = __esm({
       // imports it and the scorer compiles it, so a swapped icons.tsx
       // after verify must break the tie exactly as a swapped entry does.
       "icons",
+      // Composed pins: the partner module's bytes are graded artifact too —
+      // module-verbatim hashes them, the mounts inject their CSS, and the
+      // demo executes them in a stranger's browser. Left unscored, a
+      // post-verify swap of composed/<Name>/<file> would ride a passing
+      // module-verbatim in the stored report — the entry-swap class
+      // (ADR-018 §1c) reopened one directory down.
+      "composed",
       "evidence-triple",
       "evidence-absent-crop",
       "diff-legend"
@@ -10033,9 +10252,18 @@ var init_server = __esm({
         description: "Publish a VERIFIED bundle to the user's portal \u2014 phase one of the browser-approved publish. Re-publishing an already-published component completes in one call. A component's FIRST publish is a human-only decision the portal enforces: this call requests the approval and returns the approve-page link \u2014 RELAY IT to the user verbatim, along with which account the result says to be signed in as (they click Approve in the browser; approving includes accepting the design system's publishing terms, which is their decision to make, never yours to urge). Then call tendril_publish_wait to finish. You cannot approve this yourself: the portal only accepts the decision from their signed-in browser, never from this machine's token. Requires a green verify (the CLI refuses a declined run) and a portal session (tendril_login).",
         schema: z13.object({
           bundleDir: str("bundle directory (verified \u2014 carries component.json and verify-evidence)"),
-          portal: optStr("portal origin override for self-hosted portals (defaults to the stored session's portal)")
+          portal: optStr("portal origin override for self-hosted portals (defaults to the stored session's portal)"),
+          designSystemName: optStr(
+            "first publish only: a PROPOSED display name for the design system, prefilled on the approve card where the human names or picks it \u2014 pass the design's human name when you know it (the Figma file's title, the design system the user named); without a proposal the card prefills the raw Figma file key, and a plain Approve makes that key the permanent name"
+          )
         }),
-        argv: (i) => ["publish", i["bundleDir"], "--approve-start", ...typeof i["portal"] === "string" ? ["--to", i["portal"]] : []]
+        argv: (i) => [
+          "publish",
+          i["bundleDir"],
+          "--approve-start",
+          ...typeof i["designSystemName"] === "string" ? ["--design-system-name", i["designSystemName"]] : [],
+          ...typeof i["portal"] === "string" ? ["--to", i["portal"]] : []
+        ]
       },
       {
         name: "tendril_publish_wait",
@@ -14136,7 +14364,7 @@ function composedPins(hostSet, libraryRoots) {
       }
       const moduleFiles = [];
       let fileIssue;
-      for (const name of [manifest.entry, "styles.css", "tokens.css", "fonts.css"]) {
+      for (const name of [manifest.entry, "styles.css", "tokens.css", "fonts.css", "icons.tsx"]) {
         const file = path39.join(bundleDir, name);
         if (!existsSync32(file)) {
           if (name === manifest.entry || name === "styles.css") {
@@ -16203,6 +16431,7 @@ __export(compose_exports, {
   IMPLICIT_PARENT_SCAN_MAX_ENTRIES: () => IMPLICIT_PARENT_SCAN_MAX_ENTRIES,
   buildCompositionEntries: () => buildCompositionEntries,
   compositionPairsFor: () => compositionPairsFor,
+  openPairsAgainstStanding: () => openPairsAgainstStanding,
   renderBindingsRemediation: () => renderBindingsRemediation,
   runCompose: () => runCompose,
   substitutionPairs: () => substitutionPairs,
@@ -16211,6 +16440,31 @@ __export(compose_exports, {
 import { createHash as createHash13 } from "node:crypto";
 import { existsSync as existsSync39, readFileSync as readFileSync35, readdirSync as readdirSync16 } from "node:fs";
 import path48 from "node:path";
+function openPairsAgainstStanding(pairs, standing) {
+  const byKey = new Map(standing.map((c) => [fromStoredRel(c.partner.key), c]));
+  const open = [];
+  for (const p of pairs) {
+    const decided = byKey.get(p.key);
+    if (decided === void 0) {
+      open.push(p);
+      continue;
+    }
+    if (decided.status !== "confirmed") continue;
+    const covered = new Set(decided.instances.map((i) => `${i.hostRep}\0${i.instanceId}`));
+    const delta = p.instances.filter((i) => !covered.has(`${i.hostRep}\0${i.instanceId}`));
+    if (delta.length === 0) continue;
+    open.push({
+      ...p,
+      instances: delta,
+      growsConfirmed: true,
+      disclosures: [
+        `GROWTH: this pair stands CONFIRMED with ${String(decided.instances.length)} instance(s), and the recordings now derive ${String(delta.length)} more (evidence can grow a set \u2014 a new evidence class, a bindings enrichment). Confirming ADDS the new instance(s) to the standing decision; the original confirmation \u2014 and the partner bytes it pinned \u2014 stays exactly as decided. Not confirming leaves them unjoined and this ask returns.`,
+        ...p.disclosures
+      ]
+    });
+  }
+  return open;
+}
 function renderBindingsRemediation(r) {
   if (r === void 0) return void 0;
   const hostQ = quoteArg(path48.resolve(r.hostSet));
@@ -16242,7 +16496,6 @@ function compositionPairsFor(hostSet, roots) {
     if (parsed.success) standing.push(parsed.data);
     else invalid++;
   }
-  const decidedKeys = new Set(standing.map((c) => fromStoredRel(c.partner.key)));
   const proposalRows = /* @__PURE__ */ new Map();
   for (const e of edges) {
     if (e.hostSet !== hostSet || e.kind !== "proposal") continue;
@@ -16253,7 +16506,7 @@ function compositionPairsFor(hostSet, roots) {
     if (row.remediation === void 0 && e.remediation !== void 0) row.remediation = e.remediation;
     proposalRows.set(key, row);
   }
-  return { open: pairs.filter((p) => !decidedKeys.has(p.key)), proposals: [...proposalRows.values()], standing, invalid, ...skippedParent !== void 0 ? { skippedParent } : {} };
+  return { open: openPairsAgainstStanding(pairs, standing), proposals: [...proposalRows.values()], standing, invalid, ...skippedParent !== void 0 ? { skippedParent } : {} };
 }
 function substitutionPairs(edges, hostSet) {
   const pairs = /* @__PURE__ */ new Map();
@@ -16357,8 +16610,7 @@ function runComposeConfirm(flags, hostSet, roots) {
     }
     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 open = openPairsAgainstStanding(pairs, standing);
   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
 `);
@@ -16432,6 +16684,13 @@ PAIR ${p.displayName}${p.figmaFile !== void 0 ? ` (file ${p.figmaFile})` : " \u2
         remediation: "Spell the pair key exactly as printed in brackets."
       });
     }
+    if (open.some((p) => p.key === k && p.growsConfirmed === true)) {
+      fail(flags, ExitCode.InputValidation, {
+        error: `--decline "${k}" names a GROWTH ask on a pair that stands CONFIRMED \u2014 a standing confirmation is not re-litigated by a decline`,
+        code: "composition-growth-not-declinable",
+        remediation: "Leave the new instance(s) unconfirmed (they stay unjoined and the ask returns), or confirm to add them to the standing decision."
+      });
+    }
   }
   const entries = buildCompositionEntries(hostSet, open, declineKeys);
   const decided = flags.confirmCompositions === true ? entries : entries.filter((e) => declineKeys.has(e.partner.key));
@@ -16480,11 +16739,38 @@ function writeCompositionDecisions(hostSet, decided) {
     if (!parsed.success) return { ok: false, refusal: `compositions[${i}] in the host manifest is not a valid v1 entry \u2014 a standing human decision could not be re-validated, so nothing was written` };
     standing.push(parsed.data);
   }
-  const decidedKeys = new Set(standing.map((c) => fromStoredRel(c.partner.key)));
-  const fresh = decided.filter((e) => !decidedKeys.has(fromStoredRel(e.partner.key)));
-  const alreadyDecided = decided.filter((e) => decidedKeys.has(fromStoredRel(e.partner.key))).map((e) => e.partner.key);
-  if (fresh.length > 0) writeManifest(hostSet, { ...raw, compositions: [...standing, ...fresh] });
-  return { ok: true, written: fresh, alreadyDecided };
+  const normKeys = standing.map((c) => fromStoredRel(c.partner.key));
+  const dupKey = normKeys.find((k, i) => normKeys.indexOf(k) !== i);
+  if (dupKey !== void 0) {
+    return { ok: false, refusal: `two standing composition entries normalize to one pair key (${dupKey}) \u2014 repair the manifest by hand before deciding anything new; nothing was written` };
+  }
+  const byIndex = new Map(normKeys.map((k, i) => [k, i]));
+  const fresh = [];
+  const grown = [];
+  const alreadyDecided = [];
+  for (const e of decided) {
+    const at = byIndex.get(fromStoredRel(e.partner.key));
+    if (at === void 0) {
+      fresh.push(e);
+      continue;
+    }
+    const held = standing[at];
+    if (held.status === "confirmed" && e.status === "confirmed") {
+      const covered = new Set(held.instances.map((i) => `${i.hostRep}\0${i.instanceId}`));
+      const delta = e.instances.filter((i) => !covered.has(`${i.hostRep}\0${i.instanceId}`));
+      if (delta.length === 0) {
+        alreadyDecided.push(e.partner.key);
+        continue;
+      }
+      const merged = { ...held, instances: [...held.instances, ...delta] };
+      standing[at] = merged;
+      grown.push(merged);
+      continue;
+    }
+    alreadyDecided.push(e.partner.key);
+  }
+  if (fresh.length > 0 || grown.length > 0) writeManifest(hostSet, { ...raw, compositions: [...standing, ...fresh] });
+  return { ok: true, written: [...fresh, ...grown], alreadyDecided };
 }
 var COMPOSE_DESCRIPTION, NOTE2, IMPLICIT_PARENT_SCAN_MAX_ENTRIES;
 var init_compose2 = __esm({
@@ -16510,7 +16796,7 @@ var init_compose2 = __esm({
       output: {
         sets: "string[] \u2014 recording sets indexed (--list)",
         edges: "per-instance edges: kind (substitution | nested | ask | proposal | external | hidden \u2014 hidden = invisible in every recorded pose, disclosed and never confirmable), partners, pose (variant node id + per-set rep slugs), disclosures (--list)",
-        openPairs: "with --set: undecided id-backed pairs awaiting a human decision",
+        openPairs: "with --set: id-backed pairs awaiting a human decision \u2014 undecided pairs, plus GROWTH deltas (growsConfirmed: true) on confirmed pairs whose derivable instance set grew; a growth confirm merges into the standing entry, and --decline refuses growth asks (composition-growth-not-declinable)",
         standing: "with --set: persisted confirmations/declines (asked once)",
         note: "string \u2014 what this command does NOT do"
       },
@@ -17648,7 +17934,7 @@ function runRecordStatus(opts) {
       const setDir = path49.resolve(opts.setDir);
       const { open, proposals, standing, invalid } = compositionPairsFor(setDir, [opts.library !== void 0 ? path49.resolve(opts.library) : path49.dirname(setDir)]);
       return {
-        openPairs: open.map((p) => ({ displayName: p.displayName, pairKey: p.key, instances: p.instances.length })),
+        openPairs: open.map((p) => ({ displayName: p.displayName, pairKey: p.key, instances: p.instances.length, ...p.growsConfirmed === true ? { growsConfirmed: true } : {} })),
         // Name-only proposals (field, 2026-08-26): the host-side
         // surface an MCP-recorded host embedding a later partner never
         // had — not confirmable, but never silent either; the
@@ -17679,14 +17965,25 @@ function runRecordStatus(opts) {
     if ("unavailable" in composition) {
       process.stdout.write(`COMPOSITION discovery UNAVAILABLE \u2014 ${composition.unavailable}
 `);
-    } else if (composition.openPairs.length > 0) {
-      process.stdout.write(
-        `COMPOSITION ${composition.openPairs.length} unconfirmed partner pair(s): ${composition.openPairs.map((p) => `${p.displayName} [pair-key ${p.pairKey}] (${p.instances} instance(s))`).join(", ")} \u2014 this set's recording references other recorded components. Before generating the HOST, record/generate the partner and have a human decide the pairing: \`${tendrilCommand(`compose --set ${path49.resolve(opts.setDir)}`)}\` lists it; confirmation is human-only.
+    } else {
+      const growth = composition.openPairs.filter((p) => p.growsConfirmed === true);
+      const fresh = composition.openPairs.filter((p) => p.growsConfirmed !== true);
+      if (fresh.length > 0) {
+        process.stdout.write(
+          `COMPOSITION ${fresh.length} unconfirmed partner pair(s): ${fresh.map((p) => `${p.displayName} [pair-key ${p.pairKey}] (${p.instances} instance(s))`).join(", ")} \u2014 this set's recording references other recorded components. Before generating the HOST, record/generate the partner and have a human decide the pairing: \`${tendrilCommand(`compose --set ${path49.resolve(opts.setDir)}`)}\` lists it; confirmation is human-only.
 `
-      );
-    } else if (composition.confirmed > 0) {
-      process.stdout.write(`COMPOSITION ${composition.confirmed} confirmed partner pair(s) on this set (composed pins apply at generation)
+        );
+      }
+      if (growth.length > 0) {
+        process.stdout.write(
+          `COMPOSITION GROWTH: ${growth.map((p) => `${p.displayName} [pair-key ${p.pairKey}] has ${p.instances} newly-derived instance(s) awaiting the same human decision`).join(", ")} \u2014 the standing confirmation is untouched; confirming adds them: \`${tendrilCommand(`compose --set ${path49.resolve(opts.setDir)}`)}\`
+`
+        );
+      }
+      if (composition.confirmed > 0) {
+        process.stdout.write(`COMPOSITION ${composition.confirmed} confirmed partner pair(s) on this set (composed pins apply at generation)
 `);
+      }
     }
     if (!("unavailable" in composition) && composition.nameOnly.length > 0) {
       for (const p of composition.nameOnly) {
@@ -19727,10 +20024,17 @@ function runEngineBrief(opts) {
           `COMPOSITION DISCOVERY PARTIAL: the set's parent directory (${skippedParent.dir}) holds ${String(skippedParent.entries)} entries and was not scanned as a recordings library \u2014 sibling sets there are invisible to pairing. Pass --library <dir> to scan a specific library deliberately.`
         );
       }
-      if (open.length > 0) {
-        const componentNames = [...new Set(open.map((p) => p.displayName))];
+      const fresh = open.filter((p) => p.growsConfirmed !== true);
+      const growth = open.filter((p) => p.growsConfirmed === true);
+      if (fresh.length > 0) {
+        const componentNames = [...new Set(fresh.map((p) => p.displayName))];
+        disclosures.push(
+          `COMPOSITION PAIRS UNDECIDED: this recording references ${componentNames.length} other recorded component(s) (${fresh.map((p) => `${p.displayName} [pair-key ${p.key}]: ${p.instances.length} instance(s)`).join("; ")}) and no human has decided the pairing. This brief treats the component as SELF-CONTAINED \u2014 you will re-implement the partner's pixels locally. If composition is wanted: generate the partner bundle first, have a human run \`${tendrilCommand(`compose --set ${path55.resolve(task.set)}`)}\` in their terminal, and re-emit this brief. Proceeding as-is is valid; it just is not composition.`
+        );
+      }
+      if (growth.length > 0) {
         disclosures.push(
-          `COMPOSITION PAIRS UNDECIDED: this recording references ${componentNames.length} other recorded component(s) (${open.map((p) => `${p.displayName} [pair-key ${p.key}]: ${p.instances.length} instance(s)`).join("; ")}) and no human has decided the pairing. This brief treats the component as SELF-CONTAINED \u2014 you will re-implement the partner's pixels locally. If composition is wanted: generate the partner bundle first, have a human run \`${tendrilCommand(`compose --set ${path55.resolve(task.set)}`)}\` in their terminal, and re-emit this brief. Proceeding as-is is valid; it just is not composition.`
+          `COMPOSITION PARTIALLY CONFIRMED: ${growth.map((p) => `${p.displayName} [pair-key ${p.key}] \u2014 ${p.instances.length} newly-derived instance(s) (${p.instances.map((i) => `${i.hostRep}/${i.instanceId}`).join(", ")}) are NOT yet confirmed`).join("; ")}. The confirmed instances compose via the pinned partner module below; the unconfirmed ones you implement LOCALLY from the recorded pose. To compose them too: a human confirms the growth (\`${tendrilCommand(`compose --set ${path55.resolve(task.set)}`)}\`) and this brief is re-emitted.`
         );
       }
       if (proposals.length > 0) {
@@ -20723,6 +21027,7 @@ async function runPublish(opts) {
       figmaFile: opened.value.figmaFile,
       rulerVersion: opened.value.rulerVersion,
       resumed: opened.value.resumed === true,
+      approvalSpent: opened.value.approvalSpent === true,
       files: uploaded,
       recordings: carried === void 0 ? { carried: false, ...recordingNote === void 0 ? {} : { note: recordingNote } } : {
         carried: true,
@@ -20737,6 +21042,10 @@ async function runPublish(opts) {
       const reused = uploaded.filter((u) => u.deduplicated).length;
       if (opened.value.resumed === true) process.stdout.write(`resumed the unfinished publish of ${componentName}
 `);
+      if (opened.value.approvalSpent === true) {
+        process.stdout.write(`your earlier browser Approve of ${componentName} authorized this first publish
+`);
+      }
       process.stdout.write(`published ${componentName} \u2014 ${String(uploaded.length)} files`);
       process.stdout.write(reused > 0 ? ` (${String(reused)} you already had)
 ` : "\n");
@@ -20858,7 +21167,11 @@ function pendingApprovalPath() {
   return path58.join(path58.dirname(sessionPath()), "pending-publish.json");
 }
 async function runApprovalFlow(opts, client, bundleDir, input) {
-  const requested = await client.requestApproval({ componentName: input.componentName, figmaFile: input.figmaFile });
+  const requested = await client.requestApproval({
+    componentName: input.componentName,
+    figmaFile: input.figmaFile,
+    ...opts.designSystemName === void 0 ? {} : { proposedDesignSystemName: opts.designSystemName }
+  });
   if (!requested.ok) refuse(opts, requested, "approval-request-refused");
   const approval = requested.value;
   const who = await client.whoami?.();
@@ -21092,10 +21405,8 @@ function openPairsFor(hostSet, roots) {
   const pairs = substitutionPairs(edges, hostSet);
   const { raw } = readManifestFile(hostSet);
   const rawStanding = Array.isArray(raw["compositions"]) ? raw["compositions"] : [];
-  const decidedKeys = new Set(
-    rawStanding.map((e) => CompositionEntrySchema.safeParse(e)).filter((p) => p.success).map((p) => fromStoredRel(p.data.partner.key))
-  );
-  return pairs.filter((p) => !decidedKeys.has(p.key));
+  const standing = rawStanding.map((e) => CompositionEntrySchema.safeParse(e)).filter((p) => p.success).map((p) => p.data);
+  return openPairsAgainstStanding(pairs, standing);
 }
 async function runComposeApproveStart(flags, hostSet, roots) {
   if (!existsSync49(path59.join(hostSet, "recording-set.json"))) {
@@ -24419,7 +24730,7 @@ function buildProgram() {
       ...local["revoke"] !== void 0 ? { revoke: local["revoke"] } : {}
     });
   });
-  program.command("publish").description("Put a verified bundle and its evidence on a page, at a URL you can send to someone. Refuses a run the ruler declined.").argument("<bundleDir>", "bundle directory that has already been verified").option("--to <url>", "the portal to publish to (or set TENDRIL_PORTAL_URL)").option("--name <name>", "library label for this component (default: the bundle manifest's own name)").option("--approve-start", "first publish only: request the browser approval, print the link, persist the pending state and exit \u2014 the tendril_publish tool's phase one").option("--approve-wait", "resume a pending approval: poll until the human decides in the browser, then publish \u2014 phase two").option("--wait-window <seconds>", "with --approve-wait: return after this many undecided seconds (exit 0, status approval-pending, the pending slot kept) instead of blocking to the 31-minute cap \u2014 the MCP bridge's bounded-poll shape").option("--recordings <dir>", "the recording set to carry, when the bundle's stamped path is stale (a bundle moved between machines usually has one)").option("--no-recordings", "publish without carrying the recording set \u2014 the component still publishes, but no other machine can pull the recordings it was measured against").action(async (bundleDir, _o, cmd) => {
+  program.command("publish").description("Put a verified bundle and its evidence on a page, at a URL you can send to someone. Refuses a run the ruler declined.").argument("<bundleDir>", "bundle directory that has already been verified").option("--to <url>", "the portal to publish to (or set TENDRIL_PORTAL_URL)").option("--name <name>", "library label for this component (default: the bundle manifest's own name)").option("--design-system-name <name>", "first publish only: propose a display name for the design system on the approve card (the human names or picks it there; without a proposal the card prefills the raw Figma file key)").option("--approve-start", "first publish only: request the browser approval, print the link, persist the pending state and exit \u2014 the tendril_publish tool's phase one").option("--approve-wait", "resume a pending approval: poll until the human decides in the browser, then publish \u2014 phase two").option("--wait-window <seconds>", "with --approve-wait: return after this many undecided seconds (exit 0, status approval-pending, the pending slot kept) instead of blocking to the 31-minute cap \u2014 the MCP bridge's bounded-poll shape").option("--recordings <dir>", "the recording set to carry, when the bundle's stamped path is stale (a bundle moved between machines usually has one)").option("--no-recordings", "publish without carrying the recording set \u2014 the component still publishes, but no other machine can pull the recordings it was measured against").action(async (bundleDir, _o, cmd) => {
     const flags = globalFlags(cmd.parent);
     const local = cmd.opts();
     const argv = cmd.parent?.args ?? process.argv;
@@ -24429,6 +24740,7 @@ function buildProgram() {
       bundleDir,
       ...local["to"] !== void 0 ? { to: local["to"] } : {},
       ...local["name"] !== void 0 ? { name: local["name"] } : {},
+      ...local["designSystemName"] !== void 0 ? { designSystemName: local["designSystemName"] } : {},
       ...local["approveStart"] !== void 0 ? { approveStart: local["approveStart"] } : {},
       ...local["approveWait"] !== void 0 ? { approveWait: local["approveWait"] } : {},
       // Parsed, never filtered: a bad value must refuse loudly in

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tendrilapp/cli",
-  "version": "0.1.53",
+  "version": "0.1.54",
   "description": "Figma design systems → verified React components. CLI ruler + MCP server.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",