@bridge-ds/mcp 0.4.1 → 0.6.0

package/dist/{chunk-MXMMPO7F.js → chunk-M7DUTFIQ.js}

@@ -71,8 +71,9 @@ import {
   unreadableShipTeams,
   unreadableTeams,
   validateLayered,
+  variantKeyOf,
   whoCanShipSentence
-} from "./chunk-QTO4EP6V.js";
+} from "./chunk-E4D5KPIQ.js";
 
 // src/lib.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -1571,10 +1572,16 @@ var GitHubClient = class _GitHubClient {
   async addComment(issueNumber, body) {
     await this.request("POST", `${this.repoPath}/issues/${issueNumber}/comments`, { body });
   }
-  /** Comments on an issue or pull request, oldest first (first 100: the sticky preview comment is posted early). */
+  /**
+   * Comments on an issue or pull request, oldest first (first 100: the sticky preview comment is posted early).
+   * `authorAssociation` is GitHub's OWNER, MEMBER, COLLABORATOR, CONTRIBUTOR, NONE... (suggestion approvals read it).
+   */
   async listIssueComments(issueNumber) {
-    const r = await this.request("GET", `${this.repoPath}/issues/${issueNumber}/comments?per_page=100`);
-    return r.map((c) => ({ id: c.id, body: c.body ?? "", author: c.user?.login ?? "unknown", updatedAt: c.updated_at }));
+    const r = await this.request(
+      "GET",
+      `${this.repoPath}/issues/${issueNumber}/comments?per_page=100`
+    );
+    return r.map((c) => ({ id: c.id, body: c.body ?? "", author: c.user?.login ?? "unknown", updatedAt: c.updated_at, createdAt: c.created_at ?? c.updated_at, authorAssociation: c.author_association ?? "NONE" }));
   }
   // --- Issues (component change requests) ---------------------------------------------------
   async createIssue(input) {
@@ -1921,6 +1928,17 @@ var GitHubClient = class _GitHubClient {
     this.assertToken("Updating a branch from main");
     await this.request("PUT", `${this.repoPath}/pulls/${n}/update-branch`, { expected_head_sha: expectedHeadSha });
   }
+  /**
+   * Merges the branch `head` into the branch `base` (GitHub's merges API): a merge commit on `base`, or nothing when
+   * `base` already has every commit of `head`. A conflict throws a GitHubError with status 409. Refuses protected
+   * branches and, with a branch prefix, a `base` without it.
+   */
+  async mergeIntoBranch(base, head, message) {
+    this.assertToken("Merging a branch into another");
+    this.assertWritableBranch(base);
+    const r = await this.request("POST", `${this.repoPath}/merges`, { base, head, commit_message: message });
+    return r?.sha ? { status: "merged", sha: r.sha } : { status: "up-to-date", sha: null };
+  }
   /** Posts a comment on an issue or pull request and returns its id and link. */
   async createIssueComment(n, body) {
     this.assertToken("Commenting");
@@ -2084,8 +2102,8 @@ function firstParagraph(text) {
   if (!text) return "";
   const cleaned = text.replace(/<!--[\s\S]*?-->/g, "");
   for (const para of cleaned.split(/\r?\n\s*\r?\n/)) {
-    const lines = para.split(/\r?\n/).filter((l) => l.trim() && !/^\s*#{1,6}\s/.test(l) && !/^\s*[-*]\s*\[[ xX]\]/.test(l) && !/^\s*(Co-Authored-By|Claude-Session|Signed-off-by):/i.test(l));
-    const s = lines.join(" ").replace(/\s+/g, " ").trim();
+    const lines2 = para.split(/\r?\n/).filter((l) => l.trim() && !/^\s*#{1,6}\s/.test(l) && !/^\s*[-*]\s*\[[ xX]\]/.test(l) && !/^\s*(Co-Authored-By|Claude-Session|Signed-off-by):/i.test(l));
+    const s = lines2.join(" ").replace(/\s+/g, " ").trim();
     if (s && !/^\|/.test(s)) return s.length > 400 ? `${s.slice(0, 397)}...` : s;
   }
   return "";
@@ -2251,11 +2269,11 @@ function modeLabel(modes) {
   return s.charAt(0).toUpperCase() + s.slice(1);
 }
 function tokenHistory(entries, path, config) {
-  const names2 = /* @__PURE__ */ new Set([path]);
+  const names3 = /* @__PURE__ */ new Set([path]);
   const out = [];
   const sorted = [...entries].sort((a, b) => Date.parse(b.date) - Date.parse(a.date));
   for (const e of sorted) {
-    const hits = e.changes.filter((c) => names2.has(c.path));
+    const hits = e.changes.filter((c) => names3.has(c.path));
     for (const c of hits) {
       const modes = config ? fileModes(config, c.file) : {};
       out.push({
@@ -2283,7 +2301,7 @@ function tokenHistory(entries, path, config) {
         ...c.descriptionAfter !== void 0 ? { descriptionAfter: c.descriptionAfter } : {}
       });
     }
-    for (const c of hits) if (c.kind === "renamed" && c.from) names2.add(c.from);
+    for (const c of hits) if (c.kind === "renamed" && c.from) names3.add(c.from);
   }
   return out;
 }
@@ -2413,7 +2431,7 @@ function planRevert(input) {
   }
   const prLink = entry.pr ? entry.pr.url ? `[#${entry.pr.number}](${entry.pr.url})` : `#${entry.pr.number}` : `commit ${entry.sha.slice(0, 7)}`;
   const title = `Revert: ${entry.title}`;
-  const lines = [
+  const lines2 = [
     `Reverts ${prLink} ("${entry.title}"), merged ${entry.date.slice(0, 10)} by ${entry.author}.`,
     "",
     `Original reason: ${entry.why}`,
@@ -2421,11 +2439,11 @@ function planRevert(input) {
     "Bridge computed the inverse token edits against the current base branch, not a blind git revert: tokens that changed again since are listed as conflicts and kept unless a reviewer chose to restore them."
   ];
   if (conflicts.length) {
-    lines.push("", "### Conflicts", "", "| Token | File | Why | Decision |", "| --- | --- | --- | --- |");
-    for (const k of conflicts) lines.push(`| \`${k.path}\` | ${k.file} | ${k.message.replace(/\|/g, "\\|")}${k.later.length ? ` Later: ${k.later.map((l) => l.pr ? `#${l.pr}` : l.id).join(", ")}.` : ""} | ${k.resolution === "use-before" ? "restore the old value" : "keep current"} |`);
+    lines2.push("", "### Conflicts", "", "| Token | File | Why | Decision |", "| --- | --- | --- | --- |");
+    for (const k of conflicts) lines2.push(`| \`${k.path}\` | ${k.file} | ${k.message.replace(/\|/g, "\\|")}${k.later.length ? ` Later: ${k.later.map((l) => l.pr ? `#${l.pr}` : l.id).join(", ")}.` : ""} | ${k.resolution === "use-before" ? "restore the old value" : "keep current"} |`);
   }
-  if (skipped.length) lines.push("", `${skipped.length} change(s) were already undone on the base branch and are left alone.`);
-  return finishPlan({ ...input, kind: "revert", title, prTitle: title, summary: lines.join("\n"), planned, conflicts, skipped, source: entry });
+  if (skipped.length) lines2.push("", `${skipped.length} change(s) were already undone on the base branch and are left alone.`);
+  return finishPlan({ ...input, kind: "revert", title, prTitle: title, summary: lines2.join("\n"), planned, conflicts, skipped, source: entry });
 }
 function planRestore(input) {
   const { current, path } = input;
@@ -2730,7 +2748,7 @@ function toOklch(rgb) {
   return { L, C, h };
 }
 var isHex = (s) => typeof s === "string" && /^#[0-9a-f]{6}$/i.test(s.trim());
-var fromHex = (hex) => [1, 3, 5].map((i) => parseInt(hex.slice(i, i + 2), 16) / 255);
+var fromHex = (hex2) => [1, 3, 5].map((i) => parseInt(hex2.slice(i, i + 2), 16) / 255);
 var round3 = (x) => Math.round(x * 1e3) / 1e3;
 var toHex = (rgb) => "#" + rgb.map((x) => Math.round(x * 255).toString(16).padStart(2, "0")).join("");
 function dtcgColor(rgb, alpha) {
@@ -2752,20 +2770,20 @@ function nearestStep(rgb) {
   for (const s of STEPS) if (Math.abs(LIGHTNESS[s] - L) < Math.abs(LIGHTNESS[best] - L)) best = s;
   return best;
 }
-function anchoredRamp(hex, pinStep) {
-  const rgb = fromHex(hex);
+function anchoredRamp(hex2, pinStep) {
+  const rgb = fromHex(hex2);
   const { L, C, h } = toOklch(rgb);
   const step = pinStep ?? nearestStep(rgb);
   const peak = Math.min(0.24, Math.max(0.02, C / BELL[step]));
-  return { hue: h, peak, step, distance: Math.abs(L - LIGHTNESS[step]), ramp: generateRamp({ hue: h, chroma: bellChroma(peak), pins: { [step]: hex.toUpperCase() } }) };
+  return { hue: h, peak, step, distance: Math.abs(L - LIGHTNESS[step]), ramp: generateRamp({ hue: h, chroma: bellChroma(peak), pins: { [step]: hex2.toUpperCase() } }) };
 }
 function neutralOffset() {
   const off = {};
-  for (const [s, hex] of Object.entries(NEUTRAL_ANCHORS)) off[s] = toOklch(fromHex(hex)).L - LIGHTNESS[s];
+  for (const [s, hex2] of Object.entries(NEUTRAL_ANCHORS)) off[s] = toOklch(fromHex(hex2)).L - LIGHTNESS[s];
   return (s) => off[s] ?? 0;
 }
-function tintedNeutral(hex) {
-  const rgb = fromHex(hex);
+function tintedNeutral(hex2) {
+  const rgb = fromHex(hex2);
   const { C, h } = toOklch(rgb);
   const ref = neutralChroma()(nearestStep(rgb));
   const scale = C < 4e-3 ? 0 : Math.min(2.5, C / ref);
@@ -2839,19 +2857,19 @@ function rampFor(input, pinStep, kind) {
     const ramp = kind === "neutral" ? generateRamp({ hue: hue2, chroma: neutralChroma(), offset: neutralOffset() }) : generateRamp({ hue: hue2, chroma: bellChroma(DEFAULT_PRIMARY_CHROMA) });
     return { ramp, anchor: `OKLCH hue ${Math.round(hue2)}` };
   }
-  const hex = String(input).trim();
-  if (!isHex(hex)) throw new Error(`"${hex}" is not a color. Use #rrggbb or a hue in degrees (0 to 360).`);
+  const hex2 = String(input).trim();
+  if (!isHex(hex2)) throw new Error(`"${hex2}" is not a color. Use #rrggbb or a hue in degrees (0 to 360).`);
   if (kind === "neutral") {
-    const n = tintedNeutral(hex);
-    return { ramp: n.ramp, anchor: `${hex.toUpperCase()} (hue ${Math.round(n.hue)})` };
+    const n = tintedNeutral(hex2);
+    return { ramp: n.ramp, anchor: `${hex2.toUpperCase()} (hue ${Math.round(n.hue)})` };
   }
-  const a = anchoredRamp(hex, pinStep);
+  const a = anchoredRamp(hex2, pinStep);
   const issue = a.distance > PIN_TOLERANCE ? {
     level: "warning",
     code: "pin-off-ladder",
-    message: `${hex.toUpperCase()} is ${a.distance > 0.12 ? "much " : ""}${toOklch(fromHex(hex)).L > LIGHTNESS[a.step] ? "lighter" : "darker"} than the ${a.step} step it is pinned to, so the ramp around it will not read as one family. Primary actions use this step: pick a ${a.step >= 600 ? "deeper" : "lighter"} color.`
+    message: `${hex2.toUpperCase()} is ${a.distance > 0.12 ? "much " : ""}${toOklch(fromHex(hex2)).L > LIGHTNESS[a.step] ? "lighter" : "darker"} than the ${a.step} step it is pinned to, so the ramp around it will not read as one family. Primary actions use this step: pick a ${a.step >= 600 ? "deeper" : "lighter"} color.`
   } : void 0;
-  return { ramp: a.ramp, anchor: `${hex.toUpperCase()} pinned at ${a.step}`, ...issue ? { issue } : {} };
+  return { ramp: a.ramp, anchor: `${hex2.toUpperCase()} pinned at ${a.step}`, ...issue ? { issue } : {} };
 }
 function aliasRamp(doc, role, ramp, description) {
   const group = getAt(doc, `palette.${role}`);
@@ -3390,7 +3408,23 @@ function patchDocsJson(original, next) {
 function cleanDraftText(text) {
   return text.replace(/\s*\u2014\s*/g, ", ").replace(/,\s*,/g, ",").replace(/^,\s*/, "").replace(/[ \t]+/g, " ").trim();
 }
+var andList = (xs) => xs.length <= 1 ? xs[0] ?? "" : `${xs.slice(0, -1).join(", ")} and ${xs[xs.length - 1]}`;
 var capital = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+var VARIANT_FIRST = ["variant", "tone", "intent", "appearance", "kind", "type", "style"];
+function shortVariant(key) {
+  const pairs = key.split(", ").map((p) => {
+    const at = p.indexOf("=");
+    return at < 0 ? { k: "", v: p.trim() } : { k: p.slice(0, at).trim(), v: p.slice(at + 1).trim() };
+  });
+  const kept = pairs.filter((p) => p.v && !/^default$/i.test(p.v));
+  if (!kept.length) return key;
+  const rank2 = (k) => {
+    const i = VARIANT_FIRST.indexOf(k.toLowerCase());
+    return i < 0 ? VARIANT_FIRST.length : i;
+  };
+  return kept.map((p, i) => ({ ...p, i })).sort((a, b) => rank2(a.k) - rank2(b.k) || a.i - b.i).map((p) => p.v).join(" ");
+}
+var shortVariants = (list) => list ? andList(list.split("; ").map(shortVariant)) : "every variant";
 var DRAFT_LINE_MAX = 120;
 function clipText(text, max) {
   const t = text.replace(/\s+/g, " ").trim().replace(/\.$/, "");
@@ -3434,8 +3468,8 @@ function validateDocsTask(x) {
 }
 var docsTaskKeys = (t) => t.kind === "sections" ? t.keys : [t.key];
 function parseDocsReply(text) {
-  const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(text);
-  const body = fenced ? fenced[1] : text;
+  const fenced2 = /```(?:json)?\s*([\s\S]*?)```/i.exec(text);
+  const body = fenced2 ? fenced2[1] : text;
   const start = body.indexOf("{");
   const end = body.lastIndexOf("}");
   if (start < 0 || end <= start) throw new Error("The reply holds no JSON object.");
@@ -3598,7 +3632,7 @@ function explorationPrBody(e, ctx) {
   const branch = `${EXPLORATION_PREFIX}${slug2}`;
   const uc = useCaseLabel(e.useCase);
   const experimental = (e.experimental ?? []).map((x) => x.trim()).filter(Boolean);
-  const lines = [
+  const lines2 = [
     `## Exploration: ${e.name.trim()}`,
     "",
     `> Not mergeable as is. This draft pull request is a sandbox on \`${branch}\`: promote it to a normal review when the idea is validated, or close it.`,
@@ -3614,14 +3648,14 @@ function explorationPrBody(e, ctx) {
     "### Try it in a product staging branch",
     ""
   ];
-  lines.push(
+  lines2.push(
     'In the product repo, on a branch that deploys to staging (production keeps the released version), install the snapshot with the command in the "Try this exploration in your product" comment below. It appears a few minutes after each push and always matches the latest commit.'
   );
-  lines.push("", "### Previews", "");
+  lines2.push("", "### Previews", "");
   const links = previewLinks(ctx.apps, { branch, ...ctx.pr ? { pr: ctx.pr } : {} });
-  if (links.length) lines.push("| App | Preview |", "| --- | --- |", ...links.map((l) => `| ${l.label} | ${l.url} |`));
-  else lines.push("Preview deploys are not set up: add `previews.apps` to `bridge.config.json` (docs/PREVIEWS.md).");
-  lines.push(
+  if (links.length) lines2.push("| App | Preview |", "| --- | --- |", ...links.map((l) => `| ${l.label} | ${l.url} |`));
+  else lines2.push("Preview deploys are not set up: add `previews.apps` to `bridge.config.json` (docs/PREVIEWS.md).");
+  lines2.push(
     "",
     "### When it is done",
     "",
@@ -3630,7 +3664,7 @@ function explorationPrBody(e, ctx) {
     "",
     `<!-- ${MARK} ${JSON.stringify({ name: e.name.trim(), purpose: e.purpose.trim(), slug: slug2, ...e.useCase ? { useCase: e.useCase } : {}, ...experimental.length ? { experimental } : {}, ...e.author ? { author: e.author } : {}, ...e.startedAt ? { startedAt: e.startedAt } : {}, ...e.source ? { source: e.source } : {}, ...e.agent ? { agent: e.agent } : {} }).replace(/-->/g, "--\\u003e")} -->`
   );
-  return lines.join("\n");
+  return lines2.join("\n");
 }
 function parseExplorationBody(body) {
   if (!body) return void 0;
@@ -3955,9 +3989,9 @@ function mergeDraftResults(p, results, at = /* @__PURE__ */ new Date()) {
       continue;
     }
     const clean = sanitizeDraftText(r);
-    const lines = sanitizeResultLines(item2, r.lines);
-    if (!clean.title && !clean.summary && !lines.length) throw new Error(`The result for "${r.id}" has no title and no summary, and no line.`);
-    next.set(r.id, { id: r.id, title: clean.title, summary: clean.summary, ...lines.length ? { lines } : {}, by: "claude", at: at.toISOString() });
+    const lines2 = sanitizeResultLines(item2, r.lines);
+    if (!clean.title && !clean.summary && !lines2.length) throw new Error(`The result for "${r.id}" has no title and no summary, and no line.`);
+    next.set(r.id, { id: r.id, title: clean.title, summary: clean.summary, ...lines2.length ? { lines: lines2 } : {}, by: "claude", at: at.toISOString() });
   }
   const merged = p.items.map((i) => next.get(i.id)).filter((r) => !!r);
   return { ...p, results: merged, status: merged.length === p.items.length ? "drafted" : "pending" };
@@ -3974,25 +4008,25 @@ function draftItemBrief(i) {
     return [`Item ${i.id}: component docs${i.component ? ` of ${i.component}` : ""} from Bridge Studio (${i.docs.path ?? i.docs.slug}): ${what}.`, "", i.docs.prompt].join("\n");
   }
   const kind = i.kind ? REQUEST_KINDS.find((k) => k.value === i.kind)?.label : void 0;
-  const cell3 = (s) => (s ?? "").replace(/\|/g, "\\|").replace(/\n/g, " ");
-  const lines = [`Item ${i.id}: ${i.scope === "request" ? "a component change request (a GitHub issue developers implement)" : "the description of a pull request with design token (variable) edits from Figma"}.`];
-  if (i.component) lines.push(`Component: ${i.component}`);
-  if (kind) lines.push(`Kind: ${kind}`);
-  if (i.components?.length) lines.push(`Components with a change request: ${i.components.join(", ")}`);
-  if (i.changes.length) lines.push("", "| What | Now | In Figma |", "| --- | --- | --- |", ...i.changes.map((c) => `| ${cell3(c.field)} | ${cell3(c.before) || "none"} | ${cell3(c.after) || "removed"} |`));
-  if (i.variables?.length) lines.push("", "| Token | Now | In Figma |", "| --- | --- | --- |", ...i.variables.map((v) => `| ${cell3(v.path)} | ${cell3(v.before) || "none"} | ${cell3(v.after) || "removed"} |`));
-  if (!i.changes.length && !i.variables?.length && !i.lines?.length) lines.push("", "No change detected: rely on the notes and the images.");
-  if (i.draft.title || i.draft.summary) lines.push("", "Starting draft, written from the changes only:", `Title: ${i.draft.title}`, `Summary: ${i.draft.summary}`);
-  if (i.notes?.trim()) lines.push("", "The designer's notes (keep their intent):", i.notes.trim());
+  const cell4 = (s) => (s ?? "").replace(/\|/g, "\\|").replace(/\n/g, " ");
+  const lines2 = [`Item ${i.id}: ${i.scope === "request" ? "a component change request (a GitHub issue developers implement)" : "the description of a pull request with design token (variable) edits from Figma"}.`];
+  if (i.component) lines2.push(`Component: ${i.component}`);
+  if (kind) lines2.push(`Kind: ${kind}`);
+  if (i.components?.length) lines2.push(`Components with a change request: ${i.components.join(", ")}`);
+  if (i.changes.length) lines2.push("", "| What | Now | In Figma |", "| --- | --- | --- |", ...i.changes.map((c) => `| ${cell4(c.field)} | ${cell4(c.before) || "none"} | ${cell4(c.after) || "removed"} |`));
+  if (i.variables?.length) lines2.push("", "| Token | Now | In Figma |", "| --- | --- | --- |", ...i.variables.map((v) => `| ${cell4(v.path)} | ${cell4(v.before) || "none"} | ${cell4(v.after) || "removed"} |`));
+  if (!i.changes.length && !i.variables?.length && !i.lines?.length) lines2.push("", "No change detected: rely on the notes and the images.");
+  if (i.draft.title || i.draft.summary) lines2.push("", "Starting draft, written from the changes only:", `Title: ${i.draft.title}`, `Summary: ${i.draft.summary}`);
+  if (i.notes?.trim()) lines2.push("", "The designer's notes (keep their intent):", i.notes.trim());
   if (i.lines?.length) {
-    lines.push("", `Change lines to write (one sentence each, at most ${DRAFT_LINE_MAX} characters, from the before and after images), each with the title of its request (at most ${DRAFT_TITLE_MAX} characters):`);
+    lines2.push("", `Change lines to write (one sentence each, at most ${DRAFT_LINE_MAX} characters, from the before and after images), each with the title of its request (at most ${DRAFT_TITLE_MAX} characters):`);
     for (const l of i.lines) {
-      lines.push(`- Line ${l.id}${l.component ? `, ${l.component}` : ""}${l.kind ? ` (${REQUEST_KINDS.find((k) => k.value === l.kind)?.label ?? l.kind})` : ""}. Starting line: ${l.line || "(none)"}${l.title ? `. Starting title: ${l.title}` : ""}`);
-      for (const c of l.changes) lines.push(`  - ${c.field}: ${c.before || "none"} -> ${c.after || "removed"}`);
+      lines2.push(`- Line ${l.id}${l.component ? `, ${l.component}` : ""}${l.kind ? ` (${REQUEST_KINDS.find((k) => k.value === l.kind)?.label ?? l.kind})` : ""}. Starting line: ${l.line || "(none)"}${l.title ? `. Starting title: ${l.title}` : ""}`);
+      for (const c of l.changes) lines2.push(`  - ${c.field}: ${c.before || "none"} -> ${c.after || "removed"}`);
     }
   }
-  if (i.images?.length) lines.push("", `Images: ${i.images.map((m) => `${m.label}${m.line ? ` (line ${m.line})` : ""} ${m.url}`).join(", ")}`);
-  return lines.join("\n");
+  if (i.images?.length) lines2.push("", `Images: ${i.images.map((m) => `${m.label}${m.line ? ` (line ${m.line})` : ""} ${m.url}`).join(", ")}`);
+  return lines2.join("\n");
 }
 var isConflict = (err) => err instanceof GitHubError ? err.status === 409 || err.status === 422 && /sha/i.test(`${err.detail ?? ""} ${err.message}`) : err?.status === 409;
 async function readPendingDrafts(client2, sessionId, branch = REQUESTS_BRANCH) {
@@ -4380,14 +4414,14 @@ function conflictRoute(o, opts = {}) {
   return { kind: "tokens", files: o.tokenFiles };
 }
 function resolutionMessage(input) {
-  const lines = input.conflicts.map((c) => `- ${c.path} (${c.file}): ${choiceFor(c, input.choices) === "theirs" ? `used the ${input.library} value` : "kept this change"}`);
+  const lines2 = input.conflicts.map((c) => `- ${c.path} (${c.file}): ${choiceFor(c, input.choices) === "theirs" ? `used the ${input.library} value` : "kept this change"}`);
   const title = input.conflicts.length ? `Bring in the latest ${input.library} and resolve ${plural(input.conflicts.length, "token conflict")}` : `Bring in the latest ${input.library}`;
   const by = input.who ? `
 
 Resolved in Bridge by @${input.who.replace(/^@/, "")}.` : "\n\nResolved in Bridge.";
-  return `${title}${lines.length ? `
+  return `${title}${lines2.length ? `
 
-${lines.join("\n")}` : ""}${by}`;
+${lines2.join("\n")}` : ""}${by}`;
 }
 function freshness(input) {
   const behindBy = typeof input.compare?.behind_by === "number" ? input.compare.behind_by : null;
@@ -4576,11 +4610,11 @@ function canAddTo(p, viewer, write) {
   return write || sameLogin(p.user?.login, viewer);
 }
 function addedComment(paths, viewer, from = "the Bridge token editor") {
-  const lines = paths.slice(0, 20).map((p) => `- \`${p}\``);
-  if (paths.length > 20) lines.push(`- and ${paths.length - 20} more`);
+  const lines2 = paths.slice(0, 20).map((p) => `- \`${p}\``);
+  if (paths.length > 20) lines2.push(`- and ${paths.length - 20} more`);
   return `${viewer ? `@${viewer} added` : "Added"} token edits from ${from}:
 
-${lines.join("\n")}`;
+${lines2.join("\n")}`;
 }
 
 // ../core/src/jira.ts
@@ -4603,6 +4637,981 @@ function branchWithJiraKey(branch, key) {
   return i < 0 ? `${key}-${branch}` : `${branch.slice(0, i + 1)}${key}-${branch.slice(i + 1)}`;
 }
 
+// ../core/src/figma-push.ts
+var where = (r) => r.allVariants ? "every variant" : shortVariants(r.variants.join("; "));
+var cap = (s) => s ? s.charAt(0).toUpperCase() + s.slice(1) : s;
+function planComponentPush(d, ctx) {
+  const issues = [...d.unknown];
+  const reasons = [];
+  const edits = /* @__PURE__ */ new Map();
+  const also = /* @__PURE__ */ new Set();
+  for (const r of d.rebinds) {
+    const label = `${cap(r.kind)} in ${where(r)}`;
+    if (!r.after.length) {
+      issues.push({ what: `${label} is no longer bound to a variable: it uses a raw value.`, todo: "Bind it to a variable, or create the variable and push it with the variables, then push again." });
+      continue;
+    }
+    const missing = r.after.filter((p) => !ctx.tierOf(p));
+    if (missing.length) {
+      issues.push({ what: `${label} uses ${missing.join(", ")}, a variable the library does not have yet.`, todo: "Push the variable first (Variables, above), then push this component again." });
+      continue;
+    }
+    if (!r.before.length) {
+      reasons.push(`${label} is bound to ${r.after.join(", ")} where code paints nothing: Claude AI adds it to the CSS.`);
+      continue;
+    }
+    if (r.before.length !== 1 || r.after.length !== 1) {
+      reasons.push(`${label} moved from ${r.before.join(", ")} to ${r.after.join(", ")}: several variables on one property, so Claude AI writes the CSS.`);
+      continue;
+    }
+    const [from, to] = [r.before[0], r.after[0]];
+    if (ctx.tierOf(from) !== "component") {
+      reasons.push(`Code paints ${r.kind} with ${from} directly, not through a ${d.component} token: Claude AI changes the CSS to ${to}.`);
+      continue;
+    }
+    const elsewhere = ctx.usedElsewhere(from, r);
+    if (elsewhere.variants.length) {
+      const v = elsewhere.variants;
+      const list2 = v.length > 3 ? `${shortVariants(v.slice(0, 3).join("; ")).replace(/ and /, ", ")} and ${v.length - 3} more` : shortVariants(v.join("; "));
+      reasons.push(`${from} also paints ${list2}: pointing it to ${to} would change them too, so Claude AI adds a token for ${where(r)}.`);
+      continue;
+    }
+    for (const c of elsewhere.components) also.add(c);
+    const prev = edits.get(from);
+    if (prev && prev.value !== `{${to}}`) {
+      reasons.push(`${from} moved to two different variables (${String(prev.value).slice(1, -1)} and ${to}): Claude AI splits it.`);
+      edits.delete(from);
+      continue;
+    }
+    edits.set(from, { op: "set", path: from, value: `{${to}}` });
+  }
+  const list = [...edits.values()];
+  if (d.needsCode || reasons.length) {
+    return {
+      route: "claude-draft",
+      said: `Claude AI drafts the code from what you changed, then a person reviews it.${list.length ? ` ${list.length === 1 ? "Its token swap goes" : "Its token swaps go"} with it.` : ""}`,
+      edits: list,
+      reasons,
+      issues,
+      alsoChanges: [...also]
+    };
+  }
+  if (list.length) {
+    const n = list.length;
+    const others = [...also];
+    const names3 = others.length > 3 ? [...others.slice(0, 3), `${others.length - 3} more`] : others;
+    const alsoLine = names3.length ? ` It also repaints ${names3.length > 1 ? `${names3.slice(0, -1).join(", ")} and ${names3[names3.length - 1]}` : names3[0]}: they use the same token${n === 1 ? "" : "s"}.` : "";
+    return { route: "token-change", said: `Exact, no AI: ${n === 1 ? `${list[0].path} points` : `${n} ${d.component} tokens point`} to the new variable${n === 1 ? "" : "s"}, checked for contrast and reviewed like any token change.${alsoLine}`, edits: list, reasons, issues, alsoChanges: others };
+  }
+  return { route: "manual", said: issues.length ? "Fix it in Figma first: nothing is sent until Bridge can read it." : "Nothing to send.", edits: [], reasons, issues, alsoChanges: [] };
+}
+function specsUsage(specs, component) {
+  const own = specs.components.find((x) => x.name === component) ?? specs.components.find((x) => x.component === component);
+  return (path, r) => {
+    const variants = [];
+    const components = [];
+    for (const c of specs.components) {
+      for (const v of c.variants) {
+        if (!Object.values(v.values).some((fields) => Object.values(fields ?? {}).includes(path))) continue;
+        const key = variantKeyOf(v.props);
+        if (c === own) {
+          if (!r.variants.includes(key)) variants.push(key);
+        } else if (!components.includes(c.name)) components.push(c.name);
+      }
+    }
+    return { variants, components };
+  };
+}
+function componentContrastPairs(edits, pairs, tokens) {
+  const out = /* @__PURE__ */ new Map();
+  for (const e of edits) {
+    const target = tokens.aliasOf(e.path);
+    if (!target) continue;
+    const group = e.path.split(".")[0];
+    const sibling = (other) => tokens.paths.find((p) => p !== e.path && p.split(".")[0] === group && tokens.aliasOf(p) === other) ?? other;
+    for (const p of pairs) {
+      if (p.foreground === target) out.set(`${e.path}|${sibling(p.background)}`, { ...p, foreground: e.path, background: sibling(p.background) });
+      if (p.background === target) out.set(`${sibling(p.foreground)}|${e.path}`, { ...p, foreground: sibling(p.foreground), background: e.path });
+    }
+  }
+  return [...out.values()];
+}
+var FROM_FIGMA_LABEL = "from-figma";
+var WAITING_FOR_CLAUDE_LABEL = "waiting-for-claude";
+var DRAFTED_BY_CLAUDE_LABEL = "drafted-by-claude";
+var FIGMA_SPEC_DIR = ".bridge/figma";
+var ORIGIN_MARK = "bridge-from-figma";
+var hidden = (data) => `<!-- ${ORIGIN_MARK} ${JSON.stringify(data).replace(/-->/g, "--\\u003e")} -->`;
+function parseFigmaOrigin(body) {
+  if (!body) return void 0;
+  const m = new RegExp(`<!-- ${ORIGIN_MARK} (\\{[\\s\\S]*?\\}) -->`).exec(body);
+  if (!m) return void 0;
+  try {
+    const o = JSON.parse(m[1]);
+    return typeof o.component === "string" && (o.route === "token-change" || o.route === "claude-draft") ? o : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function figmaOriginSection(o) {
+  const design = o.url ? `[${o.figmaName}](${o.url})` : `"${o.figmaName}"`;
+  const who = o.requestedBy ? ` by @${o.requestedBy}` : "";
+  const status = o.route === "token-change" ? "Exact token change, no AI: Bridge read the token swap from the Figma component." : o.status === "drafted" ? "**Drafted by Claude AI** from the Figma spec. A person reviews it before it ships." : `**Waiting for Claude AI:** this branch carries the spec only, as a request. Claude writes the code here (\`bridge_get_figma_change\`, or \`bridge figma show <number>\`), then it is labelled ${DRAFTED_BY_CLAUDE_LABEL}.`;
+  return [`**From Figma:** ${design}${who}. Once it ships, a pull in the DS Bridge plugin rebuilds the component from this code.`, "", status, "", hidden(o)].join("\n");
+}
+function withFigmaOrigin(body, o) {
+  let b = (body ?? "").trim();
+  const at = b.indexOf("**From Figma:**");
+  const mark = b.indexOf(`<!-- ${ORIGIN_MARK} `);
+  if (at >= 0 && mark > at) {
+    const end = b.indexOf("-->", mark);
+    b = `${b.slice(0, at)}${b.slice(end + 3)}`.trim();
+  }
+  return `${figmaOriginSection(o)}${b ? `
+
+${b}` : ""}`;
+}
+var figmaSpecSlug = (d) => slugify(`${d.component} ${d.title}`, 48) || "component-change";
+var figmaSpecPath = (d) => `${FIGMA_SPEC_DIR}/${figmaSpecSlug(d)}.json`;
+var kindLabel2 = (k) => REQUEST_KINDS.find((x) => x.value === k)?.label ?? "Change";
+function formatFigmaSpec(d, plan) {
+  return `${JSON.stringify({ ...d, tokenEdits: plan.edits, reasons: plan.reasons, unknown: plan.issues }, null, 2)}
+`;
+}
+function parseFigmaSpec(text) {
+  if (!text) return void 0;
+  try {
+    const s = JSON.parse(text);
+    return s && s.v === 1 && typeof s.component === "string" && Array.isArray(s.changes) ? s : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function figmaDraftBrief(d, ctx) {
+  const dir = `${(ctx.componentsDir ?? "packages/react/src/components").replace(/\/+$/, "")}/${d.component}`;
+  const suggested = "suggestion" in ctx;
+  const variants = Object.entries(d.variantAxes).map(([axis, values]) => `${axis}: ${values.join(", ")}`);
+  const props = d.properties.filter((p) => p.type !== "VARIANT").map((p) => `${p.name} (${p.type.toLowerCase().replace("_", " ")}, default ${p.default || "empty"})`);
+  return [
+    suggested ? "Draft the code for a component change made in Figma, sent as a Bridge suggestion (this issue)." : `Draft the code for a component change made in Figma, on the library branch ${ctx.branch} (draft pull request #${ctx.pr}).`,
+    "",
+    d.coded ? `Component: ${d.component} (${dir})` : `New component: ${d.component} (create ${dir})`,
+    `Kind: ${kindLabel2(d.kind)}`,
+    `Change: ${d.title}`,
+    ...d.line?.trim() ? [`What changes: ${d.line.trim()}`] : [],
+    "",
+    d.summary.trim(),
+    "",
+    ...d.changes.length ? ["Changes in Figma:", ...d.changes.map((c) => `- ${c.field}: ${c.before ?? "(none)"} -> ${c.after ?? "(removed)"}`), ""] : [],
+    ...variants.length ? ["Variant matrix in Figma:", ...variants.map((v) => `- ${v}`), ""] : [],
+    ...props.length ? ["Properties in Figma:", ...props.map((p) => `- ${p}`), ""] : [],
+    ...d.tokenEdits?.length ? ["Token swaps to make too (exact, with bridge_propose_token_change on this branch or by hand in the token files):", ...d.tokenEdits.map((e) => `- ${e.path} -> ${String(e.value)}`), ""] : [],
+    ...d.reasons?.length ? ["Why this needs code:", ...d.reasons.map((r) => `- ${r}`), ""] : [],
+    `Spec: ${ctx.specPath} ${suggested ? "in the suggestion" : "on the branch"} has the bound variables of every variant (token paths), the layers of every variant and what code gave Figma before.`,
+    ...d.figma?.url ? [`Design: ${d.figma.url}`] : [],
+    ...d.images?.length ? ["Screenshot:", ...d.images.map((u) => `- ${u}`)] : [],
+    "",
+    "Steps:",
+    "suggestion" in ctx ? "1. Apply the suggestion on a new branch: bridge apply <this issue number> (it writes the spec file), or start a branch from the default branch." : `1. git fetch origin && git checkout ${ctx.branch}`,
+    `2. Write the change in ${dir}: the TSX on Base UI, the CSS module with tokens only (the bound variables of the spec, as token paths), the stories (examples), docs.json and a changeset. Follow ${ctx.agentsFile ?? "AGENTS.md"}.`,
+    "3. Run npm run specs so component-specs.json matches the code, then npm test.",
+    "suggestion" in ctx ? '4. Commit, push and open a pull request that says "Closes #<this issue number>", so the suggestion closes when it ships. A person reviews it.' : `4. Commit and push to ${ctx.branch}, then call bridge_mark_figma_change_drafted { pr: ${ctx.pr} } (CLI: bridge figma drafted ${ctx.pr}). The branch is then labelled ${DRAFTED_BY_CLAUDE_LABEL} and a person reviews it.`,
+    "",
+    "Rules:",
+    "- Never invent a token or a value: use the variables the spec lists. A value the library lacks is a token change, said in the pull request.",
+    "- Keep every existing variant and prop unchanged unless the spec changes it.",
+    `- If the spec is unclear, comment on the ${suggested ? "suggestion" : "pull request"} instead of guessing.`
+  ].join("\n");
+}
+function figmaDraftBody(d, plan, o) {
+  const cell4 = (s) => s.replace(/\|/g, "\\|").replace(/\n/g, " ");
+  const rows = d.changes.length ? ["| What | Code now | In Figma |", "| --- | --- | --- |", ...d.changes.map((c) => `| ${cell4(c.field)} | ${cell4(c.before ?? "")} | ${cell4(c.after ?? "")} |`), ""] : [];
+  return withFigmaOrigin(
+    [
+      `## ${d.coded ? `${kindLabel2(d.kind)} for ${d.component}` : `New component: ${d.component}`}`,
+      "",
+      d.summary.trim(),
+      "",
+      ...d.line?.trim() ? [`**What changes:** ${d.line.trim()}`, ""] : [],
+      ...rows,
+      ...d.images?.length ? [...d.images.map((u, i) => `![${d.component} in Figma ${i + 1}](${u})`), ""] : [],
+      ...plan.edits.length ? ["**Token swaps to make too:**", ...plan.edits.map((e) => `- \`${e.path}\` -> \`${String(e.value)}\``), ""] : [],
+      ...plan.reasons.length ? ["**Why this needs code:**", ...plan.reasons.map((r) => `- ${r}`), ""] : [],
+      ...plan.issues.length ? ["**Left in Figma (the designer fixes these first):**", ...plan.issues.map((i) => `- ${i.what} ${i.todo}`), ""] : [],
+      `**Spec:** \`${o.spec ?? figmaSpecPath(d)}\` (variant matrix, properties, bound variables and layers of every variant).`
+    ].join("\n"),
+    o
+  );
+}
+var figmaBranchTitle = (d) => requestIssueTitle(d);
+function figmaPushStatus(x) {
+  const labels = x.labels ?? [];
+  if (x.state === "merged") return { key: "shipped", label: "Shipped", sentence: "It shipped. Pull to rebuild the component from the reviewed code.", rebuild: true };
+  if (x.state !== "open") return { key: "closed", label: "Closed", sentence: "The library closed it without shipping. Pull to bring the component back to the code.", rebuild: true };
+  if (labels.includes(WAITING_FOR_CLAUDE_LABEL)) return { key: "waiting-for-claude", label: "Waiting for Claude AI", sentence: "The spec is on the library branch. Claude AI writes the code there, then a person reviews it.", rebuild: false };
+  if (labels.includes(DRAFTED_BY_CLAUDE_LABEL)) return { key: "drafted", label: "Drafted by Claude AI", sentence: "Claude AI drafted the code. A person reviews it before it ships.", rebuild: false };
+  return { key: "in-review", label: "In review", sentence: x.route === "token-change" ? "Owners review the token change." : "Owners review it.", rebuild: false };
+}
+
+// ../core/src/prod-branch.ts
+var PIECES_MARK = "bridge-pieces";
+var NEEDED_MARK = "bridge-needed-by";
+var SECTION = "### Missing from the library";
+var NEEDED_BY_LABEL = "needed-by-product";
+var hiddenJson = (mark, data) => `<!-- ${mark} ${JSON.stringify(data).replace(/-->/g, "--\\u003e")} -->`;
+var readHidden = (mark, body) => {
+  if (!body) return void 0;
+  const m = new RegExp(`<!-- ${mark} (\\{[\\s\\S]*?\\}) -->`).exec(body);
+  if (!m) return void 0;
+  try {
+    return JSON.parse(m[1]);
+  } catch {
+    return void 0;
+  }
+};
+var KIND_WORD = { "token-change": "token change", exploration: "library exploration", request: "component request", suggestion: "suggested token change" };
+function parsePiecesRecord(body) {
+  const r = readHidden(PIECES_MARK, body);
+  if (!r || !Array.isArray(r.pieces) || !Array.isArray(r.links) || typeof r.checkedAt !== "string") return void 0;
+  return r;
+}
+function piecesSection(r) {
+  const link = (p) => r.links.find((l) => l.piece === p.id);
+  const lines2 = r.pieces.length ? r.pieces.map((p) => {
+    const l = link(p);
+    return `- **${p.title}**: ${p.summary}${l ? ` ${cap2(KIND_WORD[l.kind])}: #${l.number}.` : " No library branch yet."}`;
+  }) : ["- Nothing: every value and component comes from the library."];
+  return [SECTION, "", `Checked ${r.checkedAt.slice(0, 10)}${r.headSha ? ` on ${r.headSha.slice(0, 7)}` : ""} by Bridge.`, "", ...lines2, "", hiddenJson(PIECES_MARK, r)].join("\n");
+}
+function withPiecesRecord(body, r) {
+  const b = (body ?? "").trimEnd();
+  const start = b.indexOf(SECTION);
+  const markAt = b.indexOf(`<!-- ${PIECES_MARK} `);
+  if (start >= 0 && markAt > start) {
+    const end = b.indexOf("-->", markAt);
+    return `${b.slice(0, start)}${piecesSection(r)}${end >= 0 ? b.slice(end + 3) : ""}`.trimEnd();
+  }
+  return `${b}${b ? "\n\n" : ""}${piecesSection(r)}`;
+}
+function mergePiecesRecord(prev, next) {
+  const links = [...prev?.links ?? []];
+  for (const l of next.links ?? []) {
+    const at = links.findIndex((x) => x.piece === l.piece);
+    if (at >= 0) links[at] = l;
+    else links.push(l);
+  }
+  return { ...next, links };
+}
+function withLink(r, l) {
+  return { ...r, links: [...r.links.filter((x) => x.piece !== l.piece), l] };
+}
+function neededBySection(n) {
+  const who = n.author ? ` for @${n.author}` : "";
+  const near = n.nearest ? ` The closest the library has today is ${n.nearest}${n.nearestToken ? ` (\`${n.nearestToken}\`)` : ""}.` : "";
+  return [`**Needed by:** [${n.title}](${n.url}) (#${n.pr}) in ${n.productName}${who}.${near}`, "", hiddenJson(NEEDED_MARK, n)].join("\n");
+}
+function withNeededBy(body, n) {
+  let b = (body ?? "").trim();
+  const at = b.indexOf("**Needed by:**");
+  const mark = b.indexOf(`<!-- ${NEEDED_MARK} `);
+  if (at >= 0 && mark > at) {
+    const end = b.indexOf("-->", mark);
+    b = `${b.slice(0, at)}${b.slice(end + 3)}`.trim();
+  }
+  return `${neededBySection(n)}${b ? `
+
+${b}` : ""}`;
+}
+var cap2 = (s) => s ? s.charAt(0).toUpperCase() + s.slice(1) : s;
+var forLine = (b) => `${b.productName} needs it for "${b.title.replace(/"/g, "'")}" (#${b.pr})`;
+function libraryBranchPlan(piece, branch, opts = {}) {
+  const neededBy = {
+    pr: branch.pr,
+    title: branch.title,
+    branch: branch.branch,
+    url: branch.url,
+    product: branch.productKey,
+    productName: branch.productName,
+    ...branch.author ? { author: branch.author } : {},
+    piece: piece.id,
+    pieceTitle: piece.title,
+    ...piece.nearest ? { nearest: piece.nearest.label, nearestToken: piece.nearest.token } : {}
+  };
+  const near = piece.nearest ? ` The closest the library has today is ${piece.nearest.label} (${piece.nearest.token}, ${piece.nearest.value}).` : "";
+  if (piece.kind === "token" && piece.token) {
+    const t = piece.token;
+    const files = t.files.length ? t.files : [void 0];
+    const edits = files.map((file) => ({
+      op: "add",
+      path: t.path,
+      type: t.type,
+      value: t.value,
+      description: `${cap2(piece.name)}: ${forLine(branch)}.${files.length > 1 ? " Same value in every theme: review it in each." : ""}`,
+      ...file ? { file } : {}
+    }));
+    return { kind: "token-change", title: `Add ${t.path}`, summary: `${forLine(branch)}: ${piece.summary}${near}`, edits, neededBy };
+  }
+  if (piece.kind === "variant" && piece.component && opts.mode === "suggest") {
+    const request2 = {
+      component: piece.component,
+      kind: "new-variant",
+      title: piece.title,
+      summary: `${forLine(branch)}: ${piece.summary}${near}`,
+      changes: piece.values.slice(0, 6).map((v) => ({ field: v.property ?? v.category, after: v.value })),
+      source: opts.source ?? "mcp",
+      ...opts.requestedBy ? { requestedBy: opts.requestedBy } : {}
+    };
+    return { kind: "request", title: piece.title, request: request2, neededBy };
+  }
+  if (piece.kind === "variant" && piece.component) {
+    const values = piece.values.map((v) => `${v.property ?? v.category} ${v.value}`).join(", ");
+    const exploration = {
+      name: piece.title,
+      purpose: `${forLine(branch)}: ${/^[aeiou]/i.test(piece.name) ? "an" : "a"} ${piece.name} ${piece.aspect ?? "style"} on ${piece.component} (${values}).${near}`,
+      useCase: "terminal",
+      experimental: [piece.title],
+      source: opts.source === "figma" ? "figma" : opts.source ?? "mcp"
+    };
+    const brief = [
+      `Add the ${piece.name} ${piece.aspect ?? "style"} to ${piece.component} in the library, on this exploration branch.`,
+      `The product branch writes it by hand: ${values}. Express it with tokens (a component or semantic token per value), add it to the component's props, docs and examples, and keep every existing ${piece.component} unchanged.`,
+      piece.nearest ? `Say in the pull request why ${piece.nearest.label} is not enough, or recommend it instead.` : ""
+    ].filter(Boolean).join(" ");
+    return { kind: "exploration", title: piece.title, exploration, neededBy, brief };
+  }
+  const name = piece.component ?? cap2(piece.name);
+  const request = {
+    component: name,
+    kind: "new-component",
+    title: `Add ${name}`,
+    summary: `${forLine(branch)}: ${piece.summary}${near}`,
+    changes: piece.values.slice(0, 6).map((v) => ({ field: v.property ?? v.category, after: v.value })),
+    source: opts.source ?? "mcp",
+    ...opts.requestedBy ? { requestedBy: opts.requestedBy } : {}
+  };
+  return { kind: "request", title: `New component: ${name}`, request, neededBy };
+}
+var STATUS_LABEL = {
+  draft: "Draft",
+  "in-review": "In review",
+  changes: "Changes requested",
+  approved: "Approved",
+  shipped: "Shipped",
+  closed: "Closed",
+  exploring: "Being built",
+  requested: "Requested",
+  "in-progress": "In progress",
+  done: "Done",
+  declined: "Declined",
+  outdated: "Outdated"
+};
+var names2 = (people2) => people2.length <= 2 ? people2.map((p) => `@${p}`).join(" and ") : `@${people2[0]} and ${people2.length - 1} more`;
+var SUGGESTION_LINK_STATUS = {
+  "needs-review": "in-review",
+  "changes-requested": "changes",
+  approved: "approved",
+  applying: "in-progress",
+  applied: "shipped",
+  declined: "declined",
+  outdated: "outdated"
+};
+function linkStatus(x) {
+  const make = (key, people2 = [], verb = "reviews") => {
+    const label = STATUS_LABEL[key];
+    const tail = people2.length ? ` \xB7 ${names2(people2)} ${people2.length === 1 ? verb : verb.replace(/s$/, "")}` : "";
+    return { key, label, people: people2, line: `${label}${tail}` };
+  };
+  if (x.kind === "suggestion") {
+    const key = SUGGESTION_LINK_STATUS[x.status];
+    return make(key, key === "in-progress" ? [...x.assignees ?? []] : [], "builds");
+  }
+  if (x.kind === "request") {
+    if (x.state === "closed") return make(x.stateReason === "not_planned" ? "declined" : "done");
+    return x.implemented ? make("in-progress", [...x.assignees ?? []], "builds") : make("requested", [...x.assignees ?? []], "builds");
+  }
+  if (x.state === "merged") return make("shipped");
+  if (x.state !== "open") return make("closed");
+  if ((x.labels ?? []).includes("exploration")) return make("exploring");
+  if (x.draft) return make("draft");
+  const latest = /* @__PURE__ */ new Map();
+  for (const r of x.reviews ?? []) if (r.user && r.state !== "COMMENTED") latest.set(r.user, r.state);
+  const states = [...latest.values()];
+  if (states.includes("CHANGES_REQUESTED")) return make("changes", [...latest].filter(([, s]) => s === "CHANGES_REQUESTED").map(([u]) => u), "asks");
+  const waiting = [...x.requestedReviewers ?? []];
+  if (states.includes("APPROVED") && !waiting.length) return make("approved");
+  return make("in-review", waiting);
+}
+function libraryPreviewState(x) {
+  if (x.kind === "suggestion") {
+    if (x.lifecycle === "closed") return { key: "declined", sentence: `The library declined this suggestion.${x.nearest ? ` Ask Claude to use ${x.nearest} instead.` : ""}`, action: null };
+    if (x.lifecycle === "merged") return x.behindMain === 0 ? { key: "switched", sentence: "Your branch uses the published version.", action: null } : { key: "published", sentence: "The library applied the suggestion. Switch your branch to the published version.", action: { kind: "switch", label: "Switch to the published version" } };
+    return { key: "nothing-yet", sentence: "Nothing to preview yet: owners review the suggestion, then a developer applies it. Your branch keeps its own value until then.", action: null };
+  }
+  if (x.kind === "request") {
+    if (x.lifecycle === "closed") return { key: "declined", sentence: `The library declined this request.${x.nearest ? ` Ask Claude to use ${x.nearest} instead.` : ""}`, action: null };
+    if (x.lifecycle === "merged") return x.behindMain === 0 ? { key: "switched", sentence: "Your branch uses the published version.", action: null } : { key: "published", sentence: "The library built it. Switch your branch to the published version, then ask Claude to use it.", action: { kind: "switch", label: "Switch to the published version" } };
+    return { key: "nothing-yet", sentence: "Nothing to preview yet: the library builds it first. Your branch keeps its own version until then.", action: null };
+  }
+  if (x.lifecycle === "merged") {
+    if (x.behindMain === 0) return { key: "switched", sentence: "Your branch uses the published version.", action: null };
+    return { key: "published", sentence: "The library published it. Switch your branch to the published version.", action: { kind: "switch", label: "Switch to the published version" } };
+  }
+  if (x.lifecycle === "closed") return { key: "declined", sentence: `The library closed it without shipping.${x.nearest ? ` Ask Claude to use ${x.nearest} instead.` : ""}`, action: null };
+  if (!x.hasChanges) return { key: "nothing-yet", sentence: "The library branch has no change yet. Claude adds it there, then your branch can use its preview.", action: null };
+  if (x.missing === 0) return { key: "preview", sentence: "Your branch uses a preview of the library branch. When the library publishes it, switch to the real version here in one click.", action: null };
+  if (x.missing !== null && x.total !== null && x.missing < x.total) return { key: "outdated", sentence: "The library branch changed since your branch took its preview.", action: { kind: "refresh-preview", label: "Get the latest preview" } };
+  return { key: "not-used", sentence: "Your branch does not use the library branch yet.", action: { kind: "use-preview", label: "Use its preview in my branch" } };
+}
+var nPieces = (n) => `${n} ${n === 1 ? "piece" : "pieces"}`;
+function productBranchSentence(r, opts = {}) {
+  if (!r) return { lead: "Not checked against the library yet.", strong: "", rest: " Ask Claude what is missing from the library." };
+  const n = r.pieces.length;
+  if (!n) return { lead: "Built with the library.", strong: " Nothing is missing", rest: ": every value and component comes from it." };
+  const linked = r.pieces.filter((p) => r.links.some((l) => l.piece === p.id));
+  const openers = [...new Set(linked.map((p) => r.links.find((l) => l.piece === p.id)).map((l) => l.agent ? opts.agentName ?? "Claude AI" : l.openedBy && l.openedBy === opts.viewer ? "you" : l.openedBy ? `@${l.openedBy}` : "someone"))];
+  const by = openers.length === 1 ? openers[0] : "your team";
+  const was = n === 1 ? "was" : "were";
+  if (linked.length === n) {
+    const what = n === 1 ? "a library branch for it" : "library branches for them";
+    return { lead: "Built with the library. ", strong: `${nPieces(n)} ${was} missing`, rest: `, and ${by} opened ${what}.` };
+  }
+  if (!linked.length) return { lead: "Built with the library. ", strong: `${nPieces(n)} ${n === 1 ? "is" : "are"} missing`, rest: n === 1 ? ": open a library branch for it." : ": open a library branch for each." };
+  return { lead: "Built with the library. ", strong: `${nPieces(n)} ${was} missing`, rest: `: ${linked.length} ${linked.length === 1 ? "has" : "have"} a library branch, ${n - linked.length} still ${n - linked.length === 1 ? "needs" : "need"} one.` };
+}
+function pieceId(parts) {
+  return slugify(parts.filter(Boolean).join(" "), 48);
+}
+var TONE_WORDS = ["neutral", "success", "warning", "danger", "info", "error", "critical", "accent", "brand", "primary", "secondary"];
+function tokenLabel(path) {
+  const parts = path.split(".");
+  const tone = parts.find((p) => TONE_WORDS.includes(p));
+  if (tone) return tone;
+  const meaningful = parts.filter((p) => !/^(color|bg|fg|text|border|default|base|value|\d+)$/.test(p));
+  return meaningful[meaningful.length - 1] ?? parts[parts.length - 1] ?? path;
+}
+function proposedTokenPath(nearest, name, category) {
+  const slug2 = slugify(name, 32);
+  if (!nearest) return `${category === "color" ? "color" : category}.${slug2}`;
+  const parts = nearest.split(".");
+  const toneAt = parts.findIndex((p) => TONE_WORDS.includes(p));
+  if (toneAt > 0) return [...parts.slice(0, toneAt), slug2, ...parts.slice(toneAt + 1)].join(".");
+  return [...parts.slice(0, -1), slug2].join(".");
+}
+
+// ../core/src/suggestions.ts
+var SUGGESTION_SCHEMA = "bridge.suggestion/1";
+var SUGGESTION_LABEL = "bridge-suggestion";
+var SUGGESTION_KINDS = ["token-change", "docs", "component-spec", "brand", "revert", "config"];
+var SUGGESTION_STATE_LABELS = {
+  "needs-review": "suggestion: needs review",
+  "changes-requested": "suggestion: changes requested",
+  approved: "suggestion: approved",
+  applying: "suggestion: applying"
+};
+var SUGGESTION_LIMITS = {
+  body: 65536,
+  /** The readable part of the body (tables are cut with "and N more"). */
+  human: 12e3,
+  /** The JSON block in the body. */
+  inline: 48e3,
+  /** The JSON block of one continuation comment. */
+  part: 6e4,
+  /** Continuation comments at most (about 480 KB of file contents). */
+  maxParts: 8
+};
+var SuggestionError = class extends Error {
+  constructor(code2, message) {
+    super(message);
+    this.code = code2;
+    this.name = "SuggestionError";
+  }
+  code;
+};
+var SUGGESTION_TOO_LARGE = "Too large for a suggestion: split it, or ask a developer to open it directly.";
+var utf8 = (text) => new TextEncoder().encode(text);
+var hex = (words) => words.map((w) => (w >>> 0).toString(16).padStart(8, "0")).join("");
+function padded(bytes) {
+  const len = bytes.length;
+  const total = Math.ceil((len + 9) / 64) * 64;
+  const buf = new Uint8Array(total);
+  buf.set(bytes);
+  buf[len] = 128;
+  const view = new DataView(buf.buffer);
+  view.setUint32(total - 8, Math.floor(len / 536870912), false);
+  view.setUint32(total - 4, len * 8 >>> 0, false);
+  return view;
+}
+var K256 = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+function sha256Hex(text) {
+  const view = padded(utf8(text));
+  const h = [1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225];
+  const w = new Array(64);
+  const rotr = (x, n) => x >>> n | x << 32 - n;
+  for (let off = 0; off < view.byteLength; off += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(off + i * 4, false);
+    for (let i = 16; i < 64; i++) {
+      const a2 = w[i - 15];
+      const b2 = w[i - 2];
+      const s0 = rotr(a2, 7) ^ rotr(a2, 18) ^ a2 >>> 3;
+      const s1 = rotr(b2, 17) ^ rotr(b2, 19) ^ b2 >>> 10;
+      w[i] = w[i - 16] + s0 + w[i - 7] + s1 | 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = h;
+    for (let i = 0; i < 64; i++) {
+      const t1 = hh + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + (e & f ^ ~e & g) + K256[i] + w[i] | 0;
+      const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    h[0] = h[0] + a | 0;
+    h[1] = h[1] + b | 0;
+    h[2] = h[2] + c | 0;
+    h[3] = h[3] + d | 0;
+    h[4] = h[4] + e | 0;
+    h[5] = h[5] + f | 0;
+    h[6] = h[6] + g | 0;
+    h[7] = h[7] + hh | 0;
+  }
+  return hex(h);
+}
+function sha1Bytes(bytes) {
+  const view = padded(bytes);
+  const h = [1732584193, 4023233417, 2562383102, 271733878, 3285377520];
+  const w = new Array(80);
+  const rotl = (x, n) => x << n | x >>> 32 - n;
+  for (let off = 0; off < view.byteLength; off += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(off + i * 4, false);
+    for (let i = 16; i < 80; i++) w[i] = rotl(w[i - 3] ^ w[i - 8] ^ w[i - 14] ^ w[i - 16], 1);
+    let [a, b, c, d, e] = h;
+    for (let i = 0; i < 80; i++) {
+      const [f, k] = i < 20 ? [b & c | ~b & d, 1518500249] : i < 40 ? [b ^ c ^ d, 1859775393] : i < 60 ? [b & c | b & d | c & d, 2400959708] : [b ^ c ^ d, 3395469782];
+      const t = rotl(a, 5) + f + e + k + w[i] | 0;
+      e = d;
+      d = c;
+      c = rotl(b, 30);
+      b = a;
+      a = t;
+    }
+    h[0] = h[0] + a | 0;
+    h[1] = h[1] + b | 0;
+    h[2] = h[2] + c | 0;
+    h[3] = h[3] + d | 0;
+    h[4] = h[4] + e | 0;
+  }
+  return hex(h);
+}
+function gitBlobSha(text) {
+  const body = utf8(text);
+  const head = utf8(`blob ${body.length}\0`);
+  const all = new Uint8Array(head.length + body.length);
+  all.set(head);
+  all.set(body, head.length);
+  return sha1Bytes(all);
+}
+function canonicalJson(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(v) {
+  if (Array.isArray(v)) return v.map((x) => x === void 0 ? null : sortKeys(x));
+  if (v && typeof v === "object" && !(v.toJSON instanceof Function)) {
+    const out = {};
+    for (const k of Object.keys(v).sort()) {
+      const x = v[k];
+      if (x !== void 0) out[k] = sortKeys(x);
+    }
+    return out;
+  }
+  return v;
+}
+function shaForm(p) {
+  if (!p.files) return p;
+  return { ...p, files: p.files.map(({ part: _part, ...f }) => f) };
+}
+function suggestionPayloadSha(p) {
+  return sha256Hex(canonicalJson(shaForm(p)));
+}
+var KIND_SUBJECT = {
+  "token-change": "Tokens",
+  docs: "Docs",
+  "component-spec": "Component",
+  brand: "Brand",
+  revert: "Revert",
+  config: "Settings"
+};
+function suggestionSubject(p) {
+  if (p.kind === "component-spec" && p.componentSpec?.component) return p.componentSpec.component;
+  if (p.kind === "docs" && p.docs?.length) {
+    const names3 = [...new Set(p.docs.map((d) => d.component))];
+    return names3.length === 1 ? names3[0] : KIND_SUBJECT.docs;
+  }
+  return KIND_SUBJECT[p.kind];
+}
+function suggestionIssueTitle(p) {
+  const t = p.title.trim().replace(/\.$/, "");
+  return `${suggestionSubject(p)}: ${t.charAt(0).toLowerCase()}${t.slice(1)}`;
+}
+function suggestionLabels(p, opts = {}) {
+  return [
+    .../* @__PURE__ */ new Set([
+      SUGGESTION_LABEL,
+      `suggestion: ${p.kind}`,
+      `source: ${p.source}`,
+      `tier: ${p.tier.tier}`,
+      SUGGESTION_STATE_LABELS[opts.state ?? "needs-review"],
+      ...p.links?.neededBy ? [NEEDED_BY_LABEL] : [],
+      ...p.links?.figma || p.source === "figma" ? [FROM_FIGMA_LABEL] : [],
+      ...p.links?.exploration ? [EXPLORATION_LABEL] : [],
+      ...opts.labels ?? []
+    ])
+  ];
+}
+function suggestionStateFromLabels(labels) {
+  return Object.entries(SUGGESTION_STATE_LABELS).find(([, l]) => labels.includes(l))?.[0];
+}
+function suggestionStatus(i) {
+  const prs = i.linkedPrs ?? [];
+  if (i.state === "closed") return prs.some((p) => p.merged) || i.stateReason === "completed" ? "applied" : "declined";
+  if (prs.some((p) => p.state === "open") || i.applied) return "applying";
+  if (i.outdated) return "outdated";
+  return i.review ?? "needs-review";
+}
+var bridgeMcpInstallCommand = (repo) => `claude mcp add bridge -s user -- npx -y @bridge-ds/mcp --repo ${repo?.trim() || "<owner/name>"}`;
+var MARK3 = "bridge-suggestion";
+var PART_SCHEMA = "bridge.suggestion-part/1";
+var cell3 = (s) => s.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+var safeText = (s) => s.replace(/<!--/g, "&lt;!--");
+var sourceLabel2 = (s) => s === "figma" ? "Figma" : s === "studio" ? "Bridge Studio" : s === "cli" ? "the CLI" : "Claude (MCP)";
+var show2 = (v) => v === void 0 ? "" : typeof v === "string" ? v : JSON.stringify(v);
+function table(head, rows, max) {
+  if (!rows.length) return [];
+  const shown = rows.slice(0, max);
+  return [
+    `| ${head.join(" | ")} |`,
+    `| ${head.map(() => "---").join(" | ")} |`,
+    ...shown.map((r) => `| ${r.map((c) => cell3(c)).join(" | ")} |`),
+    ...rows.length > max ? ["", `and ${rows.length - max} more`] : []
+  ];
+}
+function changesSection(p, max) {
+  const out = [];
+  if (p.tokens?.changes.length) {
+    const rows = p.tokens.changes.map((c) => [
+      `\`${c.path}\`${c.kind === "renamed" && c.from ? ` (was \`${c.from}\`)` : c.kind === "added" ? " (new)" : c.kind === "removed" ? " (removed)" : ""}`,
+      c.beforeCss ?? show2(c.before),
+      c.afterCss ?? show2(c.after)
+    ]);
+    out.push(...table(["Token", "Now", "Suggested"], rows, max), "");
+  } else if (p.tokens?.edits.length) {
+    const rows = p.tokens.edits.map((e) => [`\`${e.path}\``, e.op === "rename" ? `rename to \`${e.newPath ?? ""}\`` : e.op, show2(e.value)]);
+    out.push(...table(["Token", "Edit", "Value"], rows, max), "");
+  }
+  if (p.docs?.length) out.push(...table(["Component", "Docs file"], p.docs.map((d) => [d.component, `\`${d.path}\``]), max), "");
+  if (p.componentSpec) out.push(`**Component spec:** ${p.componentSpec.component} (\`${p.componentSpec.specPath}\`)`, "");
+  if (p.files?.length) {
+    const rows = p.files.map((f) => [`\`${f.path}\``, f.beforeSha === null ? "new" : f.afterSha === null ? "deleted" : "changed"]);
+    out.push(...table(["File", "Change"], rows, max), "");
+  }
+  return out;
+}
+function checksSection(p, max) {
+  const c = p.checks;
+  const failing = c.contrast.filter((x) => !x.pass);
+  const rows = [...failing, ...c.contrast.filter((x) => x.pass)].map((x) => [x.pair, x.mode ?? "", x.before.toFixed(2), x.after.toFixed(2), String(x.min), x.pass ? "pass" : "**fails**"]);
+  return [
+    "## Checks when suggested",
+    "",
+    `- Token validation: ${c.newErrors ? `**${c.newErrors} new error(s)**` : "no new errors"}`,
+    `- Contrast: ${c.contrast.length ? failing.length ? `**${failing.length} failing pair(s)**` : `${c.contrast.length} pair(s) checked, all pass` : "no pair affected"}`,
+    `- Risk tier: ${p.tier.tier} (\`${p.tier.bump}\`), ${p.tier.tier === 1 ? "one approval" : "design and tech approval"}`,
+    `- Impact: ${c.impact ? `${c.impact} token(s) resolve to a new value` : "no other token changes value"}`,
+    "",
+    ...rows.length ? [...table(["Pair", "Mode", "Before", "After", "Min", "Result"], rows, max), ""] : []
+  ];
+}
+function linksSection(p) {
+  const l = p.links ?? {};
+  const out = [];
+  if (l.neededBy) out.push(`- Needed by ${l.neededBy.productName}: [#${l.neededBy.pr} ${cell3(l.neededBy.title)}](${l.neededBy.url})`);
+  if (l.figma?.url) out.push(`- Design: [Open in Figma](${l.figma.url})`);
+  if (l.exploration) out.push(`- Exploration: \`${l.exploration}\``);
+  if (l.supersedes) out.push(`- Replaces suggestion #${l.supersedes}`);
+  for (const v of p.previews ?? []) out.push(`- ${cell3(v.label)}: ${v.url}`);
+  return out.length ? ["## Previews and links", "", ...out, ""] : [];
+}
+function humanPart(p, details, max, repo) {
+  return [
+    `## Suggested change: ${safeText(p.title.trim())}`,
+    "",
+    safeText(p.summary.trim()),
+    "",
+    ...changesSection(p, max),
+    ...details?.trim() ? [safeText(details.trim()), ""] : [],
+    ...checksSection(p, max),
+    ...linksSection(p),
+    "## How to apply",
+    "",
+    "- CLI: `bridge apply <this issue number>` (add `--dry-run` to check it first, `--patch` for a patch file)",
+    '- Claude Code with the Bridge MCP server: ask "Apply Bridge suggestion #<this issue number>" (tool `bridge_apply_suggestion`).',
+    `  One-time install: \`${bridgeMcpInstallCommand(repo)}\``,
+    "",
+    "The pull request that applies it must say `Closes #<this issue number>`, so this suggestion closes when it merges.",
+    "",
+    `<sub>Suggested from ${sourceLabel2(p.source)}${p.suggestedBy ? ` by @${p.suggestedBy.replace(/^@/, "")}` : ""} with Bridge.</sub>`
+  ].join("\n");
+}
+function fitHuman(p, details, repo) {
+  for (const max of [50, 20, 8, 3]) {
+    const h2 = humanPart(p, details, max, repo);
+    if (h2.length <= SUGGESTION_LIMITS.human) return h2;
+  }
+  const h = humanPart(p, void 0, 3, repo);
+  if (h.length <= SUGGESTION_LIMITS.human) return h;
+  const note = "\n\n_The description is cut here: the full change is in the machine-readable block below._";
+  return h.slice(0, SUGGESTION_LIMITS.human - note.length) + note;
+}
+var pretty = (v) => JSON.stringify(sortKeys(v), null, 2);
+var fit = (v) => {
+  const p = pretty(v);
+  return p.length <= SUGGESTION_LIMITS.inline ? p : canonicalJson(v);
+};
+var fenced = (json) => ["```json", json, "```"].join("\n");
+function payloadBlock(json, sha, parts) {
+  return [
+    "<details><summary>Machine-readable change (Bridge suggestion v1)</summary>",
+    "",
+    `<!-- ${MARK3}:v1 sha256=${sha}${parts ? ` parts=${parts}` : ""} -->`,
+    fenced(json),
+    "",
+    "</details>"
+  ].join("\n");
+}
+function partComment(i, n, json) {
+  return [
+    `<details><summary>Machine-readable change, part ${i} of ${n} (Bridge suggestion v1)</summary>`,
+    "",
+    `<!-- ${MARK3}:v1 part ${i}/${n} sha256=${sha256Hex(json)} -->`,
+    fenced(json),
+    "",
+    "</details>"
+  ].join("\n");
+}
+function escapedEnd(s, from, budget) {
+  let used = 0;
+  let i = from;
+  while (i < s.length) {
+    const c = s.charCodeAt(i);
+    let w = 1;
+    let len = 1;
+    if (c === 34 || c === 92 || c === 8 || c === 12 || c === 10 || c === 13 || c === 9) len = 2;
+    else if (c < 32) len = 6;
+    else if (c >= 55296 && c <= 56319) {
+      const d = s.charCodeAt(i + 1);
+      if (d >= 56320 && d <= 57343) {
+        w = 2;
+        len = 2;
+      } else len = 6;
+    } else if (c >= 56320 && c <= 57343) len = 6;
+    if (used + len > budget) break;
+    used += len;
+    i += w;
+  }
+  return i;
+}
+function composeSuggestionIssue(payload, opts = {}) {
+  const problems = suggestionShapeProblems(payload);
+  if (problems.length) throw new SuggestionError("invalid", problems.join(" "));
+  if (payload.checks.blocked) throw new SuggestionError("invalid", `This change cannot be suggested: ${payload.checks.blocked}`);
+  const full = shaForm(payload);
+  const sha = suggestionPayloadSha(full);
+  const human = fitHuman(full, opts.details, opts.repo);
+  const base = { title: suggestionIssueTitle(full), labels: suggestionLabels(full, { state: opts.state, labels: opts.labels }), assignees: opts.assignees ?? [], sha };
+  const inline = fit(full);
+  if (inline.length <= SUGGESTION_LIMITS.inline) {
+    return { ...base, body: `${human}
+
+${payloadBlock(inline, sha, 0)}
+`, parts: [] };
+  }
+  const moved = (full.files ?? []).map((f, i) => ({ f, i })).filter(({ f }) => typeof f.content === "string" && f.content.length > 0);
+  const parts = [];
+  const firstPart = /* @__PURE__ */ new Map();
+  const partJson = (chunks, i, n2) => pretty({ schema: PART_SCHEMA, part: i, of: n2, files: chunks });
+  const emptyOverhead = partJson([], 9, 9).length;
+  let cur = [];
+  let room = SUGGESTION_LIMITS.part - emptyOverhead - 64;
+  for (const { f, i } of moved) {
+    const text = f.content;
+    let at = 0;
+    while (at < text.length) {
+      const entryOverhead = partJson([{ i, path: f.path, text: "" }], 9, 9).length - emptyOverhead + 8;
+      if (room - entryOverhead < 256) {
+        parts.push(cur);
+        cur = [];
+        room = SUGGESTION_LIMITS.part - emptyOverhead - 64;
+      }
+      const end = escapedEnd(text, at, room - entryOverhead);
+      if (end === at) throw new SuggestionError("too-large", SUGGESTION_TOO_LARGE);
+      if (!firstPart.has(i)) firstPart.set(i, parts.length + 1);
+      const chunk = { i, path: f.path, text: text.slice(at, end) };
+      cur.push(chunk);
+      room -= partJson([chunk], 9, 9).length - emptyOverhead + 8;
+      at = end;
+    }
+  }
+  if (cur.length) parts.push(cur);
+  if (parts.length > SUGGESTION_LIMITS.maxParts) throw new SuggestionError("too-large", SUGGESTION_TOO_LARGE);
+  const skeleton = {
+    ...full,
+    files: (full.files ?? []).map((f, i) => {
+      if (!firstPart.has(i)) return f;
+      const { content: _content, ...rest } = f;
+      return { ...rest, part: firstPart.get(i) };
+    })
+  };
+  const skeletonJson = fit(skeleton);
+  if (skeletonJson.length > SUGGESTION_LIMITS.inline) throw new SuggestionError("too-large", SUGGESTION_TOO_LARGE);
+  const n = parts.length;
+  const partBodies = parts.map((chunks, k) => {
+    const json = partJson(chunks, k + 1, n);
+    if (json.length > SUGGESTION_LIMITS.part) throw new SuggestionError("too-large", SUGGESTION_TOO_LARGE);
+    return partComment(k + 1, n, json);
+  });
+  const body = `${human}
+
+${payloadBlock(skeletonJson, sha, n)}
+`;
+  if (body.length > SUGGESTION_LIMITS.body || partBodies.some((b) => b.length > SUGGESTION_LIMITS.body)) throw new SuggestionError("too-large", SUGGESTION_TOO_LARGE);
+  return { ...base, body, parts: partBodies };
+}
+function suggestionShapeProblems(raw) {
+  const out = [];
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return ["The payload must be a JSON object."];
+  const p = raw;
+  if (p.schema !== SUGGESTION_SCHEMA) out.push(`"schema" must be "${SUGGESTION_SCHEMA}".`);
+  if (!SUGGESTION_KINDS.includes(p.kind)) out.push(`"kind" must be one of ${SUGGESTION_KINDS.join(", ")}.`);
+  if (typeof p.title !== "string" || !p.title.trim()) out.push('"title" must be a sentence.');
+  if (typeof p.summary !== "string") out.push('"summary" must be text.');
+  if (!["figma", "studio", "cli", "mcp"].includes(p.source)) out.push('"source" must be figma, studio, cli or mcp.');
+  if (typeof p.createdAt !== "string") out.push('"createdAt" must be an ISO date.');
+  const base = p.base;
+  if (!base || typeof base.ref !== "string" || typeof base.sha !== "string" || !/^[0-9a-f]{7,64}$/.test(base.sha)) out.push('"base" must be { "ref", "sha" } with the commit the change was planned on.');
+  const tier = p.tier;
+  if (!tier || ![1, 2, 3].includes(tier.tier) || !["patch", "minor", "major"].includes(tier.bump)) out.push('"tier" must be { "tier": 1, 2 or 3, "bump": patch, minor or major }.');
+  const checks = p.checks;
+  if (!checks || typeof checks.newErrors !== "number" || !Array.isArray(checks.contrast) || typeof checks.impact !== "number" || !(checks.blocked === null || typeof checks.blocked === "string"))
+    out.push('"checks" must be { "newErrors", "contrast", "blocked", "impact" }.');
+  const tokens = p.tokens;
+  if (tokens !== void 0 && (!tokens || !Array.isArray(tokens.edits) || !Array.isArray(tokens.changes))) out.push('"tokens" must be { "edits", "changes" }.');
+  if (p.docs !== void 0 && !(Array.isArray(p.docs) && p.docs.every((d) => d && typeof d.component === "string" && typeof d.path === "string"))) out.push('"docs" must be a list of { "component", "path", "after" }.');
+  const spec = p.componentSpec;
+  if (spec !== void 0 && (!spec || typeof spec.component !== "string" || typeof spec.specPath !== "string" || typeof spec.brief !== "string")) out.push('"componentSpec" must be { "component", "specPath", "spec", "brief" }.');
+  if (p.files !== void 0) {
+    if (!Array.isArray(p.files)) out.push('"files" must be a list.');
+    else {
+      const seen = /* @__PURE__ */ new Set();
+      for (const f of p.files) {
+        const ok2 = f && typeof f.path === "string" && (f.beforeSha === null || typeof f.beforeSha === "string") && (f.afterSha === null || typeof f.afterSha === "string") && (f.content === void 0 || f.content === null || typeof f.content === "string") && (f.part === void 0 || Number.isInteger(f.part) && f.part >= 1 && f.part <= SUGGESTION_LIMITS.maxParts);
+        if (!ok2) {
+          out.push('Each of "files" must be { "path", "beforeSha", "afterSha", "content"? }.');
+          break;
+        }
+        if (seen.has(f.path)) out.push(`"${f.path}" is listed twice in "files".`);
+        seen.add(f.path);
+      }
+    }
+  }
+  return out;
+}
+
+// ../core/src/suggestions-github.ts
+async function createSuggestionOnGitHub(gh, payload, opts = {}) {
+  const issue = composeSuggestionIssue(payload, { repo: gh.fullName, ...opts });
+  const created = await gh.createIssue({ title: issue.title, body: issue.body, labels: issue.labels, assignees: issue.assignees });
+  for (const [i, part] of issue.parts.entries()) {
+    try {
+      await gh.createIssueComment(created.number, part);
+    } catch (err) {
+      const why = err instanceof Error ? err.message : String(err);
+      throw new GitHubError(err instanceof GitHubError ? err.status : 500, `Suggestion #${created.number} is incomplete: part ${i + 1} of ${issue.parts.length} could not be posted (${why}). Send it again, then close #${created.number}.`);
+    }
+  }
+  const warnings = [];
+  const missing = issue.labels.filter((l) => !created.labels.includes(l));
+  if (created.labels.length && missing.length) warnings.push(`GitHub did not keep these labels on #${created.number}: ${missing.join(", ")}.`);
+  return { number: created.number, url: created.url, sha: issue.sha, parts: issue.parts.length, warnings };
+}
+
 // ../core/src/docs-proposal.ts
 var DOCS_EDITOR_ORIGIN = {
   where: "in the Bridge docs editor",
@@ -4687,10 +5696,10 @@ async function continueDocsProposalOnGitHub(gh, open, edit, opts = {}) {
 function docsProposal(edits, opts) {
   const origin = opts.origin ?? DOCS_EDITOR_ORIGIN;
   if (!edits.length) throw new Error("No docs edits in the draft.");
-  const names2 = edits.map((e) => e.component);
-  const list = names2.length === 1 ? names2[0] : `${names2.slice(0, -1).join(", ")} and ${names2[names2.length - 1]}`;
-  const title = opts.title?.trim() || `docs(${names2.length === 1 ? edits[0].slug : "components"}): usage guidance for ${list}`;
-  const slug2 = docsSlug(names2.length === 1 ? edits[0].slug : `${edits[0].slug}-and-${names2.length - 1}-more`);
+  const names3 = edits.map((e) => e.component);
+  const list = names3.length === 1 ? names3[0] : `${names3.slice(0, -1).join(", ")} and ${names3[names3.length - 1]}`;
+  const title = opts.title?.trim() || `docs(${names3.length === 1 ? edits[0].slug : "components"}): usage guidance for ${list}`;
+  const slug2 = docsSlug(names3.length === 1 ? edits[0].slug : `${edits[0].slug}-and-${names3.length - 1}-more`);
   const branch = `docs/${slug2}-${slugDate(opts.date)}-${opts.date.getTime().toString(36).slice(-4)}`;
   const csPath = `${opts.changesetDir ?? ".changeset"}/docs-${slug2}-${opts.date.getTime().toString(36)}.md`;
   const pkg = opts.packageName ?? "@bridge-ds/react";
@@ -4731,13 +5740,60 @@ ${opts.notes.trim()}
   ].filter((x, i, a) => !(x === "" && a[i - 1] === "")).join("\n");
   return { branch, title, body, files, risk, bump: "patch", labels: ["docs", origin.label, `tier-${risk.tier}`] };
 }
+var docsSource = (origin) => origin.label === DOCS_MCP_ORIGIN.label ? "mcp" : "studio";
+function docsSuggestionPayload(edits, opts) {
+  const origin = opts.origin ?? DOCS_EDITOR_ORIGIN;
+  const date = opts.date ?? /* @__PURE__ */ new Date();
+  const p = docsProposal(edits, { title: opts.title, date, origin, packageName: opts.packageName, changesetDir: opts.changesetDir });
+  const names3 = edits.map((e) => e.component);
+  const list = names3.length === 1 ? names3[0] : `${names3.slice(0, -1).join(", ")} and ${names3[names3.length - 1]}`;
+  const docs = edits.map((e) => {
+    let after;
+    try {
+      after = JSON.parse(e.after);
+    } catch {
+      throw new Error(`${e.path} is not valid JSON: fix it before sending.`);
+    }
+    return { component: e.component, path: e.path, after: cleanDocs(after) };
+  });
+  const docPaths = new Set(edits.map((e) => e.path));
+  const files = p.files.filter((f) => !docPaths.has(f.path)).map((f) => ({ path: f.path, beforeSha: null, afterSha: gitBlobSha(f.content), content: f.content }));
+  const by = opts.suggestedBy?.replace(/^@/, "");
+  return {
+    schema: SUGGESTION_SCHEMA,
+    kind: "docs",
+    title: opts.title?.trim() || (names3.length === 1 ? "Usage guidance" : `Usage guidance for ${list}`),
+    summary: [`Usage guidance for ${list}, written ${origin.where}.`, opts.notes?.trim() ?? ""].filter(Boolean).join("\n\n"),
+    source: opts.source ?? docsSource(origin),
+    ...by ? { suggestedBy: by } : {},
+    createdAt: date.toISOString(),
+    base: opts.base,
+    tier: { tier: p.risk.tier, bump: "patch" },
+    docs,
+    files,
+    checks: { newErrors: 0, contrast: [], blocked: null, impact: 0 }
+  };
+}
+async function suggestDocsOnGitHub(gh, edits, opts) {
+  if (!edits.length) throw new Error("No docs edits in the draft.");
+  const sha = opts.baseSha ?? await gh.getBranchSha(opts.base);
+  if (!sha) throw new Error(`Branch ${opts.base} not found.`);
+  const origin = opts.origin ?? DOCS_EDITOR_ORIGIN;
+  const payload = docsSuggestionPayload(edits, { base: { ref: opts.base, sha }, title: opts.title, notes: opts.notes, date: opts.date, origin, source: opts.source, suggestedBy: opts.suggestedBy });
+  const p = docsProposal(edits, { date: opts.date ?? /* @__PURE__ */ new Date(), origin });
+  const rows = p.body.split("\n").filter((l) => l.startsWith("- `"));
+  const details = [...rows, "", opts.authorLine?.trim() || defaultDocsFooter(edits, origin)].join("\n");
+  const created = await createSuggestionOnGitHub(gh, payload, { labels: ["docs", ...opts.extraLabels ?? []], details });
+  return { status: "suggested", number: created.number, url: created.url, title: payload.title, sha: created.sha, warnings: created.warnings };
+}
 async function proposeDocsOnGitHub(gh, edits, opts) {
+  if (opts.mode === "suggest") return suggestDocsOnGitHub(gh, edits, opts);
   if (opts.continueOpen !== false && edits.length === 1) {
     const e = edits[0];
     const open = await findOpenDocsProposalOnGitHub(gh, { name: e.component, slug: e.slug }, opts.base).catch(() => null);
     if (open) {
       const sha = await continueDocsProposalOnGitHub(gh, open, e, { authorLine: opts.authorLine?.trim() || defaultDocsFooter(edits, opts.origin ?? DOCS_EDITOR_ORIGIN) });
-      return { number: open.number, url: open.url, branch: open.branch, title: open.title, continued: true, unchanged: !sha };
+      return { status: "continued", number: open.number, url: open.url, branch: open.branch, title: open.title, continued: true, unchanged: !sha };
     }
   }
   const p = docsProposal(edits, { title: opts.title, notes: opts.notes, date: opts.date ?? /* @__PURE__ */ new Date(), origin: opts.origin, authorLine: opts.authorLine });
@@ -4752,7 +5808,7 @@ ${opts.commitNote ?? "Proposed with the Bridge docs editor."}`, tree, [mainSha])
   await gh.createBranch(branch, commit);
   const pr = await gh.createPullRequest({ title: prTitle, head: branch, base: opts.base, body: p.body, draft: false });
   await gh.addLabels(pr.number, [...p.labels, ...opts.extraLabels ?? []]).catch(() => false);
-  return { number: pr.number, url: pr.url, branch, title: prTitle, continued: false, unchanged: false };
+  return { status: "opened", number: pr.number, url: pr.url, branch, title: prTitle, continued: false, unchanged: false };
 }
 async function commitFileOnGitHub(gh, input) {
   const cur = await gh.getFile(input.path, input.branch);
@@ -4873,9 +5929,9 @@ var COMBINE_COMPARE_LIMIT = 300;
 async function readCombineBranch(gh, pull, opts) {
   const compare = await gh.compareDetailed(opts.base, pull.headSha);
   const files = compare.files;
-  const names2 = files.flatMap((f) => f.previous_filename ? [f.filename, f.previous_filename] : [f.filename]);
+  const names3 = files.flatMap((f) => f.previous_filename ? [f.filename, f.previous_filename] : [f.filename]);
   const start = compare.mergeBase;
-  if (!start || files.length >= COMBINE_COMPARE_LIMIT || !onlyTokens(names2, opts.tokensRoot)) return { number: pull.number, title: pull.title, tokens: false, edits: null };
+  if (!start || files.length >= COMBINE_COMPARE_LIMIT || !onlyTokens(names3, opts.tokensRoot)) return { number: pull.number, title: pull.title, tokens: false, edits: null };
   const root = opts.tokensRoot.replace(/^\/+|\/+$/g, "");
   const tokenFiles = files.filter((f) => tokenFilesOf([f.filename], root).length);
   const source = { number: pull.number, base: {}, head: {}, files: tokenFiles.map((f) => tokenFilesOf([f.filename], root)[0]) };
@@ -4889,6 +5945,350 @@ async function readCombineBranch(gh, pull, opts) {
   return { number: pull.number, title: pull.title, tokens: true, edits: changeEdits(source) };
 }
 
+// ../core/src/prod-branch-github.ts
+var PRODUCT_FILE = /\.(css|scss|sass|less|tsx|jsx|ts|js|mjs|cjs|mts|cts|astro|vue|svelte)$/;
+var SKIP_FILE = /\.d\.[cm]?ts$|\.(test|spec|stories|story)\.[cm]?[jt]sx?$|\.min\.(css|js)$/;
+var PIECES_FILE_LIMIT = 40;
+var cleanPath = (p) => p.trim().replace(/^\.?\/+|\/+$/g, "");
+function productOf(products, pull, files) {
+  const product = productOfBranch(products, { labels: pull.labels, files });
+  if (product.key === defaultProduct(products).key) throw new GitHubError(422, `This branch is a library branch (${product.name}), not a product branch: missing pieces are checked on a branch started for a product.`);
+  return product;
+}
+async function readProductBranchOnGitHub(gh, pr, opts) {
+  const pull = await gh.getPullRequest(pr);
+  const cmp = await gh.compareDetailed(pull.baseRef, pull.headSha);
+  const product = productOf(opts.products, pull, cmp.files.map((f) => f.filename));
+  const dir = product.path ? `${cleanPath(product.path)}/` : "";
+  const changed = cmp.files.filter((f) => f.status !== "removed" && (!dir || f.filename.startsWith(dir)) && PRODUCT_FILE.test(f.filename) && !SKIP_FILE.test(f.filename) && !f.filename.split("/").includes("node_modules"));
+  const read = changed.slice(0, PIECES_FILE_LIMIT);
+  const start = cmp.mergeBase ?? pull.baseRef;
+  const files = await Promise.all(
+    read.map(async (f) => {
+      const [before, after] = await Promise.all([f.status === "added" ? Promise.resolve(void 0) : gh.getFileText(f.previous_filename ?? f.filename, start), gh.getFileText(f.filename, pull.headSha)]);
+      return { path: f.filename, before: before ?? null, after: after ?? null };
+    })
+  );
+  return { pull, product, files, skipped: changed.length - read.length, record: parsePiecesRecord(pull.body) };
+}
+async function recordPiecesOnGitHub(gh, pr, check) {
+  const pull = await gh.getPullRequest(pr);
+  const record = mergePiecesRecord(parsePiecesRecord(pull.body), { checkedAt: check.checkedAt ?? (/* @__PURE__ */ new Date()).toISOString(), headSha: check.headSha ?? pull.headSha, pieces: check.pieces, fixes: check.fixes });
+  await gh.updatePullRequest(pr, { body: withPiecesRecord(pull.body, record) });
+  return record;
+}
+var productWriter = (gh, branch) => isExplorationBranch(branch) ? gh.withBranchPrefix(EXPLORATION_PREFIX) : gh;
+async function useLibraryPreviewOnGitHub(gh, input) {
+  const message = `chore(bridge): use the preview of ${input.libraryBranch} (#${input.libraryNumber})
+
+The product branch takes the library branch before it ships. Switch to the published version once it does.`;
+  try {
+    const r = await productWriter(gh, input.productBranch).mergeIntoBranch(input.productBranch, input.libraryBranch, message);
+    return { ...r, said: r.status === "merged" ? "Your branch now uses the preview of the library branch." : "Your branch already has the latest preview." };
+  } catch (err) {
+    if (err instanceof GitHubError && err.status === 409) return { status: "conflict", sha: null, said: `Your branch and the library branch change the same lines. A developer merges ${input.libraryBranch} into ${input.productBranch} by hand.` };
+    throw err;
+  }
+}
+function productBranchRef(pull, product) {
+  const name = /<!-- bridge-exploration (\{[\s\S]*?\}) -->/.exec(pull.body ?? "");
+  let title = pull.title.replace(/^[A-Z][A-Z0-9_]*-\d+\s+/, "").replace(/^Exploration:\s*/i, "");
+  let author = pull.author;
+  if (name) {
+    try {
+      const e = JSON.parse(name[1]);
+      if (e.name) title = e.name;
+      if (e.author) author = e.author;
+    } catch {
+    }
+  }
+  return { pr: pull.number, title: title.charAt(0).toUpperCase() + title.slice(1), branch: pull.headRef, url: pull.url, productKey: product.key, productName: product.name, ...author ? { author } : {} };
+}
+async function openLibraryBranchOnGitHub(gh, input) {
+  const pull = await gh.getPullRequest(input.pr);
+  const record = parsePiecesRecord(pull.body);
+  const piece = record?.pieces.find((p) => p.id === input.piece);
+  if (!record || !piece) throw new GitHubError(404, record ? `No piece "${input.piece}" on #${input.pr}. Pieces: ${record.pieces.map((p) => p.id).join(", ") || "none"}.` : `#${input.pr} was not checked yet: find its missing pieces first (bridge_missing_pieces with record, or \`bridge pieces ${input.pr} --record\`).`);
+  const product = productOf(input.products, pull, await gh.listPullRequestFiles(input.pr).then((f) => f.map((x) => x.filename), () => []));
+  const mode = input.mode ?? "direct";
+  const plan = libraryBranchPlan(piece, productBranchRef(pull, product), { source: input.source, requestedBy: input.openedBy, mode });
+  const existing = record.links.find((l) => l.piece === piece.id);
+  if (existing) return { status: "already-linked", plan, link: existing, preview: null, warnings: [] };
+  if (input.dryRun) return { status: "dry-run", plan, link: null, preview: null, warnings: [] };
+  if (!gh.canWrite) throw new GitHubError(401, mode === "suggest" ? "Suggesting a library change needs a GitHub token (issues: write)." : "Opening a library branch needs a GitHub token (contents, pull requests and issues: write).");
+  const warnings = [];
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  const who = { ...input.openedBy ? { openedBy: input.openedBy } : {}, ...input.agent ? { agent: input.agent } : {} };
+  let link;
+  if (plan.kind === "token-change") {
+    if (!input.writeTokens) throw new GitHubError(422, "This piece is a token: open it where the token files are read (Bridge Studio, bridge_open_library_branch or `bridge pieces open`).");
+    const r = await input.writeTokens(plan, { mode });
+    link = r.status === "suggested" ? { piece: piece.id, kind: "suggestion", number: r.number, url: r.url, title: plan.title, at, ...who } : { piece: piece.id, kind: "token-change", number: r.number, url: r.url, title: plan.title, branch: r.branch, at, ...who };
+  } else if (plan.kind === "exploration") {
+    const r = await startExplorationOnGitHub(gh, { ...plan.exploration, ...input.openedBy ? { author: input.openedBy } : {}, ...input.agent ? { agent: input.agent } : {} }, { base: input.base, ...input.exploration, labels: [NEEDED_BY_LABEL] });
+    link = { piece: piece.id, kind: "exploration", number: r.pr, url: r.url, title: plan.title, branch: r.branch, at, ...who };
+  } else {
+    const issue = composeRequestIssue(plan.request, { labels: [NEEDED_BY_LABEL] });
+    const r = await gh.createIssue(issue);
+    link = { piece: piece.id, kind: "request", number: r.number, url: r.url, title: plan.title, at, ...who };
+  }
+  try {
+    if (link.kind === "request" || link.kind === "suggestion") {
+      const issue = await gh.getIssue(link.number);
+      await gh.updateIssue(link.number, { body: withNeededBy(issue.body, plan.neededBy) });
+      if (link.kind === "suggestion" && !issue.labels.includes(NEEDED_BY_LABEL)) await gh.addLabels(link.number, [NEEDED_BY_LABEL]);
+    } else {
+      const lib = await gh.getPullRequest(link.number);
+      await gh.updatePullRequest(link.number, { body: withNeededBy(lib.body, plan.neededBy) });
+      await gh.addLabels(link.number, [NEEDED_BY_LABEL]);
+    }
+  } catch (err) {
+    if (err instanceof GitHubError && err.auth === "rejected") throw err;
+    warnings.push(`The library side does not say who needs it yet (${err.message}). Add "Needed by #${input.pr}" to #${link.number} on GitHub.`);
+  }
+  try {
+    const fresh = await gh.getPullRequest(input.pr);
+    const next = withLink(parsePiecesRecord(fresh.body) ?? record, link);
+    await gh.updatePullRequest(input.pr, { body: withPiecesRecord(fresh.body, next) });
+  } catch (err) {
+    if (mode !== "suggest") throw err;
+    warnings.push(`#${input.pr} does not list #${link.number} yet (${err.message}). Add "Library: #${link.number}" to #${input.pr} on GitHub, so this piece is not sent twice.`);
+  }
+  let preview = null;
+  if ((input.usePreview ?? true) && link.kind === "token-change" && link.branch) {
+    preview = await useLibraryPreviewOnGitHub(gh, { productBranch: pull.headRef, libraryBranch: link.branch, libraryNumber: link.number }).catch((err) => {
+      warnings.push(`Your branch does not use the preview yet: ${err.message}`);
+      return null;
+    });
+  }
+  return { status: link.kind === "suggestion" ? "suggested" : "opened", plan, link, preview, warnings };
+}
+var isNote = (path) => path.startsWith(`${EXPLORATION_NOTES_DIR}/`);
+async function linkedLibraryBranchOnGitHub(gh, link, product, piece) {
+  const nearest = piece?.nearest?.label;
+  if (link.kind === "suggestion") {
+    const issue = await gh.getIssue(link.number);
+    const cached = suggestionStateFromLabels(issue.labels);
+    const s = suggestionStatus({ state: issue.state, stateReason: issue.stateReason, applied: cached === "applying", review: cached === "applying" ? void 0 : cached });
+    const status2 = linkStatus({ kind: "suggestion", status: s });
+    const lifecycle2 = s === "applied" ? "merged" : issue.state === "closed" ? "closed" : "open";
+    const behindMain2 = lifecycle2 === "merged" ? await gh.compare(product.baseRef, product.headSha).then((c) => c.behindBy, () => null) : null;
+    const preview2 = libraryPreviewState({ kind: "suggestion", lifecycle: lifecycle2, hasChanges: false, missing: null, total: null, behindMain: behindMain2, nearest });
+    return { link, piece, status: status2, preview: preview2, people: status2.people };
+  }
+  if (link.kind === "request") {
+    const issue = await gh.getIssue(link.number);
+    const status2 = linkStatus({ kind: "request", state: issue.state, stateReason: issue.stateReason });
+    const lifecycle2 = issue.state === "closed" ? issue.stateReason === "not_planned" ? "closed" : "merged" : "open";
+    const behindMain2 = lifecycle2 === "merged" ? await gh.compare(product.baseRef, product.headSha).then((c) => c.behindBy, () => null) : null;
+    const preview2 = libraryPreviewState({ kind: "request", lifecycle: lifecycle2, hasChanges: false, missing: null, total: null, behindMain: behindMain2, nearest });
+    return { link, piece, status: status2, preview: preview2, people: status2.people };
+  }
+  const lib = await gh.getPullRequest(link.number);
+  const reviews = await gh.listReviews(link.number).catch(() => []);
+  const status = linkStatus({ kind: link.kind, state: lib.state, draft: lib.draft, labels: lib.labels, requestedReviewers: lib.requestedReviewers, reviews: reviews.map((r) => ({ user: r.user, state: r.state })) });
+  const lifecycle = lib.state === "merged" ? "merged" : lib.state === "open" ? "open" : "closed";
+  let missing = null;
+  let total = null;
+  let behindMain = null;
+  let hasChanges = true;
+  if (lifecycle === "open") {
+    const [files, own, inProduct] = await Promise.all([
+      gh.listPullRequestFiles(link.number).catch(() => null),
+      gh.compare(lib.baseRef, lib.headSha).catch(() => null),
+      gh.compare(product.headSha, lib.headSha).catch(() => null)
+    ]);
+    hasChanges = files ? files.some((f) => !isNote(f.filename)) : true;
+    total = own?.aheadBy ?? null;
+    missing = inProduct?.aheadBy ?? null;
+  } else if (lifecycle === "merged") {
+    behindMain = await gh.compare(product.baseRef, product.headSha).then((c) => c.behindBy, () => null);
+  }
+  const preview = libraryPreviewState({ kind: link.kind, lifecycle, hasChanges, missing, total, behindMain, nearest });
+  return { link, piece, status, preview, people: status.people };
+}
+async function productBranchViewOnGitHub(gh, pr, opts) {
+  const pull = await gh.getPullRequest(pr);
+  const files = await gh.listPullRequestFiles(pr).then((f) => f.map((x) => x.filename), () => []);
+  const product = productOf(opts.products, pull, files);
+  const record = parsePiecesRecord(pull.body);
+  const linked = await Promise.all(
+    (record?.links ?? []).map((l) => linkedLibraryBranchOnGitHub(gh, l, { headSha: pull.headSha, baseRef: pull.baseRef }, record?.pieces.find((p) => p.id === l.piece)))
+  );
+  const open = (record?.pieces ?? []).filter((p) => !record.links.some((l) => l.piece === p.id));
+  return { pull, product, record, sentence: productBranchSentence(record, { viewer: opts.viewer, agentName: opts.agentName }), linked, open };
+}
+async function switchToPublishedOnGitHub(gh, pr) {
+  if (!gh.canWrite) throw new GitHubError(401, "Switching needs a GitHub token (contents and pull requests: write).");
+  const pull = await gh.getPullRequest(pr);
+  if (pull.state !== "open") throw new GitHubError(422, `#${pr} is ${pull.state}: only an open branch switches.`);
+  const cmp = await gh.compare(pull.baseRef, pull.headSha);
+  if (cmp.behindBy === 0) return { status: "up-to-date", said: "Your branch already uses the published version." };
+  try {
+    await gh.updatePullRequestBranch(pr, pull.headSha);
+  } catch (err) {
+    if (err instanceof GitHubError && err.status === 422) throw new GitHubError(422, `Your branch and ${pull.baseRef} change the same lines, so Bridge cannot switch it alone. Use "Update from main" to pick the token values, or ask a developer.`, err.detail);
+    throw err;
+  }
+  return { status: "switched", said: `Your branch now uses the published version from ${pull.baseRef}.` };
+}
+
+// ../core/src/token-proposal.ts
+var issueKey2 = (i) => `${i.code}|${i.path ?? ""}|${i.file ?? ""}|${i.message}`;
+function planTokenProposal(input) {
+  const { before, config } = input;
+  const r = applyTokenEdits(before, input.edits);
+  const after = new LayeredTokenSet(before.config, r.files);
+  const changes = diffLayered(before, after);
+  if (!changes.length) return null;
+  const prevErrors = new Set(validateLayered(before).map(issueKey2));
+  const newErrors = validateLayered(after).filter((i) => i.level === "error" && !prevErrors.has(issueKey2(i)));
+  const modes = config.contrast?.modes;
+  const contrast = input.pairs.length ? contrastDelta(runLayeredContrast(before, input.pairs, modes), runLayeredContrast(after, input.pairs, modes)) : [];
+  const newFailures = contrast.filter((d) => d.passBefore && !d.passAfter);
+  const impact = layeredImpact(before, after, changes);
+  const tier = classifyLayered(changes, [], config);
+  const summary2 = input.summary?.trim() || input.title;
+  const body = [composeProposalBody({ summary: summary2, changes, contrast, impact, tier, validationErrors: newErrors.length, tool: input.tool ?? "Bridge MCP" }), ...input.bodyExtra ?? []].filter(Boolean).join("\n\n");
+  const slug2 = slugify(input.title, 48) || "change";
+  const changesetPath = `${config.changesets?.dir ?? ".changeset"}/bridge-${slug2}.md`;
+  const touched = r.touched.map((f) => after.repoPath(f));
+  const files = [
+    ...r.touched.map((f) => ({ path: after.repoPath(f), content: after.files.get(f) })),
+    ...config.changesets ? [{ path: changesetPath, content: formatChangeset(config.changesets.package, tier.bump, summary2) }] : []
+  ];
+  const blocked = newErrors.length || newFailures.length ? [newErrors.length ? `${newErrors.length} new validation error(s)` : "", newFailures.length ? `${newFailures.length} contrast pair(s) would fail` : ""].filter(Boolean).join(" and ") : null;
+  return { title: input.title, summary: summary2, edits: input.edits, before, after, changes, tier, contrast, newFailures, newErrors, impact, notes: r.notes, touched, files, body, slug: slug2, blocked };
+}
+async function writeTokenProposalOnGitHub(gh, plan, opts) {
+  if (plan.blocked) throw new Error(`Not opened: ${plan.blocked}. Bridge never opens a branch that breaks the gate.`);
+  const jira = opts.jira ?? null;
+  let branch = branchWithJiraKey(`${opts.branchPrefix}${plan.slug}`, jira);
+  for (let i = 2; await gh.getBranchSha(branch).then(Boolean, () => false); i++) branch = branchWithJiraKey(`${opts.branchPrefix}${plan.slug}-${i}`, jira);
+  const commit = await gh.commitToNewBranch({ base: opts.base, branch, message: `feat(tokens): ${plan.title}
+
+Proposed through ${opts.tool ?? "Bridge MCP"}. Tier ${plan.tier.tier}.`, files: plan.files });
+  const labels = tokenLabels(plan, opts.labels, opts.labelsAfter);
+  const draft = plan.tier.tier >= 2;
+  const pr = await gh.createPullRequest({ base: opts.base, head: branch, title: titleWithJiraKey(`feat(tokens): ${plan.title}`, jira), body: plan.body, draft });
+  await gh.addLabels(pr.number, labels);
+  return { branch, commit: commit.sha, pr: pr.number, url: pr.url, labels, draft };
+}
+var tokenLabels = (plan, before = [], after = []) => [
+  .../* @__PURE__ */ new Set([...before, `tier: ${plan.tier.tier}`, ...plan.tier.tier === 3 ? ["tokens"] : [], ...plan.tier.bump === "major" ? ["breaking"] : [], ...after])
+];
+
+// ../core/src/figma-push-github.ts
+var pushSource = (d) => ["figma", "studio", "cli", "mcp"].includes(d.source) ? d.source : "figma";
+var specTier = (d) => ({ tier: 2, bump: d.kind === "new-component" || d.kind === "new-variant" || d.kind === "prop-change" ? "minor" : "patch" });
+function componentSpecSuggestionPayload(d, plan, ctx) {
+  const specPath = figmaSpecPath(d);
+  const spec = JSON.parse(formatFigmaSpec(d, plan));
+  const brief = figmaDraftBrief({ ...d, tokenEdits: plan.edits, reasons: plan.reasons }, { suggestion: true, specPath, componentsDir: ctx.componentsDir });
+  const by = (ctx.suggestedBy ?? d.requestedBy)?.replace(/^@/, "");
+  const figma = d.figma?.fileKey || d.figma?.nodeId || d.figma?.url ? { ...d.figma.fileKey ? { fileKey: d.figma.fileKey } : {}, ...d.figma.nodeId ? { nodeId: d.figma.nodeId } : {}, ...d.figma.url ? { url: d.figma.url } : {} } : void 0;
+  return {
+    schema: SUGGESTION_SCHEMA,
+    kind: "component-spec",
+    title: d.title,
+    summary: d.summary.trim() || d.title,
+    source: pushSource(d),
+    ...by ? { suggestedBy: by } : {},
+    createdAt: ctx.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    base: ctx.base,
+    tier: specTier(d),
+    componentSpec: { component: d.component, specPath, spec, brief },
+    checks: { newErrors: 0, contrast: [], blocked: null, impact: 0 },
+    ...figma ? { links: { figma } } : {}
+  };
+}
+async function openComponentPushOnGitHub(gh, input) {
+  const d = input.diff;
+  if (!input.plan && !input.tokens) throw new Error("Route the change first: pass the token facts or the plan.");
+  const plan = input.plan ?? planComponentPush(d, input.tokens);
+  if (plan.route === "manual") return { status: "not-sent", plan, link: null };
+  if (input.dryRun) return { status: "dry-run", plan, link: null };
+  const mode = input.mode ?? "direct";
+  if (!gh.canWrite) throw new GitHubError(401, mode === "suggest" ? "Suggesting a component change needs a GitHub token (issues: write)." : "Sending a component change needs a GitHub token (contents and pull requests: write).");
+  const origin = {
+    component: d.component,
+    figmaName: d.figmaName,
+    route: plan.route,
+    kind: d.kind,
+    ...d.figma?.nodeId ? { nodeId: d.figma.nodeId } : {},
+    ...d.figma?.fileKey ? { fileKey: d.figma.fileKey } : {},
+    ...d.figma?.url ? { url: d.figma.url } : {},
+    ...d.requestedBy ? { requestedBy: d.requestedBy } : {}
+  };
+  if (plan.route === "token-change") {
+    if (!input.writeTokens) throw new GitHubError(422, "This change is a token change: send it where the token files are read (the DS Bridge plugin, bridge_push_figma_component or `bridge figma push`).");
+    const figma = { ...origin.fileKey ? { fileKey: origin.fileKey } : {}, ...origin.nodeId ? { nodeId: origin.nodeId } : {}, ...origin.url ? { url: origin.url } : {} };
+    const r = await input.writeTokens({ edits: plan.edits, title: figmaBranchTitle(d), summary: d.summary.trim() || d.title, bodyExtra: [figmaOriginSection(origin)], mode, figma });
+    await gh.addLabels(r.number, [FROM_FIGMA_LABEL]);
+    if (r.status === "suggested") return { status: "suggested", plan, link: null, suggestion: { route: "token-change", number: r.number, url: r.url } };
+    return { status: "opened", plan, link: { route: "token-change", number: r.number, url: r.url, branch: r.branch } };
+  }
+  if (mode === "suggest") {
+    const sha = input.baseSha ?? await gh.getBranchSha(input.base);
+    if (!sha) throw new GitHubError(404, `Branch ${input.base} not found. Check the default branch in bridge.config.json.`);
+    const payload = componentSpecSuggestionPayload(d, plan, { base: { ref: input.base, sha }, suggestedBy: input.suggestedBy });
+    const created = await createSuggestionOnGitHub(gh, payload, { labels: [...input.labels ?? [], WAITING_FOR_CLAUDE_LABEL] });
+    return { status: "suggested", plan, link: null, suggestion: { route: "claude-draft", number: created.number, url: created.url } };
+  }
+  const spec = figmaSpecPath(d);
+  const o = { ...origin, spec, status: "spec" };
+  let branch = `${input.branchPrefix}figma-${figmaSpecSlug(d)}`;
+  for (let i = 2; await gh.getBranchSha(branch).then(Boolean, () => false); i++) branch = `${input.branchPrefix}figma-${figmaSpecSlug(d)}-${i}`;
+  await gh.commitToNewBranch({
+    base: input.base,
+    branch,
+    message: `chore(figma): spec for ${figmaBranchTitle(d)}
+
+Sent from Figma with ${input.tool ?? "the DS Bridge Figma plugin"}. Claude AI drafts the code on this branch; a person reviews it.`,
+    files: [{ path: spec, content: formatFigmaSpec(d, plan) }]
+  });
+  const pr = await gh.createPullRequest({ base: input.base, head: branch, title: figmaBranchTitle(d), body: figmaDraftBody(d, plan, o), draft: true });
+  await gh.addLabels(pr.number, [.../* @__PURE__ */ new Set([...input.labels ?? [], FROM_FIGMA_LABEL, REQUEST_LABEL, WAITING_FOR_CLAUDE_LABEL])]);
+  return { status: "opened", plan, link: { route: "claude-draft", number: pr.number, url: pr.url, branch } };
+}
+async function listFigmaChangesOnGitHub(gh, opts = {}) {
+  const pulls = await gh.listPullRequests(opts.state ?? "open");
+  const out = [];
+  for (const p of pulls) {
+    if (!p.labels.includes(FROM_FIGMA_LABEL)) continue;
+    const origin = parseFigmaOrigin(p.body);
+    if (!origin) continue;
+    out.push({ number: p.number, title: p.title, url: p.url, branch: p.headRef, origin, status: figmaPushStatus({ state: p.state, draft: p.draft, labels: p.labels, route: origin.route }) });
+  }
+  return out;
+}
+async function figmaChangeOnGitHub(gh, n, opts = {}) {
+  const pull = await gh.getPullRequest(n);
+  const origin = parseFigmaOrigin(pull.body);
+  if (!origin) throw new GitHubError(404, `#${n} was not sent from Figma (no "From Figma" block in its description).`);
+  const status = figmaPushStatus({ state: pull.state, draft: pull.draft, labels: pull.labels, route: origin.route });
+  if (origin.route === "token-change") return { pull, origin, status, spec: void 0, brief: void 0 };
+  const text = origin.spec ? await gh.getFileText(origin.spec, pull.headSha).catch(() => void 0) : void 0;
+  const spec = parseFigmaSpec(text);
+  if (!spec) throw new GitHubError(404, `The spec ${origin.spec ?? FIGMA_SPEC_DIR} is missing from ${pull.headRef}. Send the component from Figma again.`);
+  const brief = figmaDraftBrief(spec, { pr: n, branch: pull.headRef, specPath: origin.spec, componentsDir: opts.componentsDir });
+  return { pull, origin, status, spec, brief };
+}
+async function markFigmaChangeDraftedOnGitHub(gh, n) {
+  if (!gh.canWrite) throw new GitHubError(401, "Marking a branch drafted needs a GitHub token (pull requests: write).");
+  const pull = await gh.getPullRequest(n);
+  const origin = parseFigmaOrigin(pull.body);
+  if (!origin || origin.route !== "claude-draft") throw new GitHubError(422, `#${n} is not a Claude draft branch from Figma.`);
+  if (pull.state !== "open") throw new GitHubError(422, `#${n} is ${pull.state}: only an open branch is marked drafted.`);
+  const files = (await gh.listPullRequestFiles(n)).map((f) => f.filename).filter((f) => !f.startsWith(`${FIGMA_SPEC_DIR}/`));
+  if (!files.length) throw new GitHubError(422, `${pull.headRef} only carries the spec: write the component code there first, push it, then mark it drafted.`);
+  await gh.updatePullRequest(n, { body: withFigmaOrigin(pull.body, { ...origin, status: "drafted" }) });
+  await gh.removeLabel(n, WAITING_FOR_CLAUDE_LABEL).catch(() => void 0);
+  await gh.addLabels(n, [DRAFTED_BY_CLAUDE_LABEL]);
+  const labels = [...pull.labels.filter((l) => l !== WAITING_FOR_CLAUDE_LABEL), DRAFTED_BY_CLAUDE_LABEL];
+  return { status: figmaPushStatus({ state: pull.state, labels, route: origin.route }), files };
+}
+
 // ../core/src/node/git-history.ts
 var US = "";
 var RS = "";
@@ -5744,8 +7144,8 @@ function tailwindFindings(hits, offset, pos, ds) {
     else if (cat === "font") cat = /^\d{3}$/.test(v) ? "font-weight" : "font-family";
     if (cat === "color" && !isColor) continue;
     const suggestion = ds.suggest(cat, v);
-    const cap = h.kind === "palette" && suggestion && suggestion.confidence > 0.6 ? { ...suggestion, confidence: 0.6, level: "medium" } : suggestion;
-    findings.push({ ...pos(offset + h.index), category: cat, value: h.cls, source: "tailwind", ...cap ? { suggestion: cap } : {} });
+    const cap3 = h.kind === "palette" && suggestion && suggestion.confidence > 0.6 ? { ...suggestion, confidence: 0.6, level: "medium" } : suggestion;
+    findings.push({ ...pos(offset + h.index), category: cat, value: h.cls, source: "tailwind", ...cap3 ? { suggestion: cap3 } : {} });
   }
   return { findings, themeRefs };
 }
@@ -6753,9 +8153,9 @@ var DesignSystemIndex = class {
         return generic ? this.make(generic, 1, 0.3) : void 0;
       }
       case "shadow": {
-        const norm2 = (s) => s.replace(/\s+/g, " ").replace(/\s*,\s*/g, ", ").trim().toLowerCase();
+        const norm3 = (s) => s.replace(/\s+/g, " ").replace(/\s*,\s*/g, ", ").trim().toLowerCase();
         const cands = this.entries(["shadow"]);
-        const exact = cands.find((e) => norm2(e.css) === norm2(value));
+        const exact = cands.find((e) => norm3(e.css) === norm3(value));
         if (exact) return this.make(exact, 0, 1);
         const t = shadowNums(value);
         const scored = cands.map((e) => {
@@ -7181,11 +8581,11 @@ async function listComponentNames(source, config) {
 }
 var findFamily = (stories) => stories ? /title:\s*['"]([^'"/]+)\//.exec(stories)?.[1] : void 0;
 async function listComponents(source, config, withSummaries) {
-  const names2 = await listComponentNames(source, config);
-  if (!withSummaries) return names2.map((n) => ({ name: n.name }));
+  const names3 = await listComponentNames(source, config);
+  if (!withSummaries) return names3.map((n) => ({ name: n.name }));
   const dir = config.components.dir;
   return Promise.all(
-    names2.map(async ({ name, files }) => {
+    names3.map(async ({ name, files }) => {
       const docsPath = `${dir}/${name}/${name}${config.components.docsSuffix}`;
       const storiesPath = files.find((f) => /\.stories\.\w+$/.test(f));
       const [docs, stories] = await Promise.all([files.includes(docsPath) ? source.read(docsPath) : null, storiesPath ? source.read(storiesPath) : null]);
@@ -7480,6 +8880,7 @@ __export(ops_exports, {
   auditOp: () => auditOp,
   auditUi: () => auditUi,
   checkContrast: () => checkContrast,
+  designSystemIndex: () => designSystemIndex,
   draftDocsOp: () => draftDocsOp,
   getComponentOp: () => getComponentOp,
   getConfig: () => getConfig,
@@ -7503,6 +8904,247 @@ import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:f
 import { mkdir as mkdir2, writeFile as writeFile2, access } from "node:fs/promises";
 import { dirname as dirname3, isAbsolute, join as join4, resolve as resolve3 } from "node:path";
 
+// ../core/src/audit/missing-pieces.ts
+var lines = (text) => text.split(/\r?\n/);
+function lineBag(text) {
+  const bag = /* @__PURE__ */ new Map();
+  for (const l of text ? lines(text) : []) {
+    const k = l.trim();
+    if (k) bag.set(k, (bag.get(k) ?? 0) + 1);
+  }
+  return bag;
+}
+var offsetOf = (text, line, column) => {
+  let off = 0;
+  const ls = text.split("\n");
+  for (let i = 0; i < line - 1 && i < ls.length; i++) off += ls[i].length + 1;
+  return off + Math.max(0, column - 1);
+};
+function enclosingTag(text, offset) {
+  for (let i = offset - 1; i >= Math.max(0, offset - 4e3); i--) {
+    if (text[i] !== "<" || !/[A-Za-z]/.test(text[i + 1] ?? "")) continue;
+    let depth = 0;
+    let closed = false;
+    for (let j = i + 1; j < offset; j++) {
+      const c = text[j];
+      if (c === "{") depth++;
+      else if (c === "}") depth--;
+      else if (c === ">" && depth <= 0 && text[j - 1] !== "=") {
+        closed = true;
+        break;
+      }
+    }
+    if (closed) return null;
+    const m = /^<([A-Za-z][\w.]*)/.exec(text.slice(i));
+    return m ? { name: m[1], start: i } : null;
+  }
+  return null;
+}
+function childText(text, tagStart) {
+  let depth = 0;
+  for (let j = tagStart + 1; j < text.length; j++) {
+    const c = text[j];
+    if (c === "{") depth++;
+    else if (c === "}") depth--;
+    else if (c === ">" && depth <= 0 && text[j - 1] !== "=") {
+      if (text[j - 1] === "/") return null;
+      const rest = /^([^<{]*)</.exec(text.slice(j + 1));
+      const t = rest?.[1]?.trim() ?? "";
+      return t && t.split(/\s+/).length <= 3 && t.length <= 30 ? t : null;
+    }
+  }
+  return null;
+}
+function ruleClasses(text, offset) {
+  const open = text.lastIndexOf("{", offset);
+  if (open < 0) return [];
+  const prev = Math.max(text.lastIndexOf("}", open), text.lastIndexOf(";", open));
+  const selector = text.slice(prev + 1, open);
+  return [...selector.matchAll(/\.([A-Za-z_][\w-]*)/g)].map((m) => m[1]);
+}
+var GENERIC = /* @__PURE__ */ new Set(["status", "badge", "tag", "pill", "chip", "style", "styles", "root", "wrapper", "container", "item", "label", "text", "color", "bg", "is", "has", "variant", "tone", "custom", "new"]);
+function nameFromClass(cls, component) {
+  const words = cls.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s_-]+/).map((w) => w.toLowerCase()).filter(Boolean);
+  const comp = component?.toLowerCase();
+  const kept = words.filter((w) => w !== comp && !GENERIC.has(w));
+  return kept[kept.length - 1] ?? words[words.length - 1] ?? cls;
+}
+var ASPECT = { color: "tone", radius: "shape", spacing: "size", size: "size", "font-size": "size", "line-height": "size" };
+function aspectOf(values) {
+  for (const a of ["tone", "shape", "size"]) if (values.some((v) => ASPECT[v.category] === a)) return a;
+  return "style";
+}
+var norm2 = (f) => f.category === "color" ? f.value.toLowerCase() : f.value.replace(/\s+/g, "");
+function nearestOf(s) {
+  if (!s) return void 0;
+  return { token: s.token, cssVar: s.cssVar, value: s.value, level: s.level, label: tokenLabel(s.token) };
+}
+var TOKEN_TYPE = { color: "color", duration: "duration", "font-weight": "fontWeight", "line-height": "number", "z-index": "number", "font-family": "fontFamily", shadow: "shadow", easing: "cubicBezier" };
+var valueTitle = (category, value) => {
+  const v = category === "color" && /^#[0-9a-f]+$/i.test(value) ? value.toUpperCase() : value;
+  const word = { color: "color", radius: "radius", spacing: "spacing", size: "size", "font-size": "text size", "font-weight": "font weight", "line-height": "line height", shadow: "shadow", duration: "duration", easing: "easing", "z-index": "layer", "border-width": "border width", "font-family": "font" };
+  return `New ${word[category] ?? category} ${v}`;
+};
+function missingPieces(input) {
+  const { ds } = input;
+  const files = input.files.filter((f) => f.after !== null && isAuditable(f.path));
+  const fixes = [];
+  const variants = /* @__PURE__ */ new Map();
+  const tokens = /* @__PURE__ */ new Map();
+  const foreign = /* @__PURE__ */ new Map();
+  const classUse = (cls) => {
+    const re = new RegExp(`<([A-Z][\\w.]*)\\b[^<]*?styles(?:\\.${cls}\\b|\\[['"]${cls}['"]\\])`);
+    for (const f of files) {
+      const m = re.exec(f.after);
+      if (m && ds.components.has(m[1].split(".")[0])) return { component: m[1].split(".")[0], text: childText(f.after, m.index) };
+    }
+    return null;
+  };
+  for (const f of files) {
+    const after = f.after;
+    const report = auditFile(f.path, after, ds);
+    const before = lineBag(f.before);
+    const afterLines = lines(after);
+    const added = (line) => {
+      const k = afterLines[line - 1]?.trim() ?? "";
+      const n = before.get(k) ?? 0;
+      if (n > 0) {
+        before.set(k, n - 1);
+        return false;
+      }
+      return true;
+    };
+    const addedLines = /* @__PURE__ */ new Map();
+    const isNew = (line) => {
+      if (!addedLines.has(line)) addedLines.set(line, added(line));
+      return addedLines.get(line);
+    };
+    const css = report.lang === "css" || report.lang === "scss" || report.lang === "less";
+    for (const finding of report.findings) {
+      if (!isNew(finding.line)) continue;
+      const s = finding.suggestion;
+      const at = { file: f.path, line: finding.line };
+      if (s?.level === "exact" || s?.level === "high" && finding.category !== "color") {
+        fixes.push({ ...at, what: finding.value, use: s.token });
+        continue;
+      }
+      const offset = offsetOf(after, finding.line, finding.column);
+      let component = null;
+      let name = null;
+      if (css) {
+        const classes = ruleClasses(after, offset);
+        for (const cls of [...classes].reverse()) {
+          const use = classUse(cls);
+          if (use) {
+            component = use.component;
+            name = nameFromClass(cls, use.component);
+            break;
+          }
+        }
+        if (!component && classes.length) name = nameFromClass(classes[classes.length - 1]);
+      } else {
+        const tag = enclosingTag(after, offset);
+        const root = tag?.name.split(".")[0];
+        if (tag && root && ds.components.has(root)) {
+          component = root;
+          name = childText(after, tag.start);
+          const cls = /className=\{?["'`]?([\w-]+)/.exec(after.slice(tag.start, offset))?.[1];
+          if (!name && cls) name = nameFromClass(cls, root);
+        }
+      }
+      const hit = { ...at, finding };
+      if (component) {
+        const label = (name ?? "custom").toLowerCase();
+        const key2 = `${component}|${label}`;
+        const v = variants.get(key2) ?? { component, name: label, hits: [] };
+        v.hits.push(hit);
+        variants.set(key2, v);
+        continue;
+      }
+      const key = `${finding.category}|${norm2(finding)}`;
+      const t = tokens.get(key) ?? { category: finding.category, value: finding.value, name, hits: [] };
+      if (!t.name && name) t.name = name;
+      t.hits.push(hit);
+      tokens.set(key, t);
+    }
+    for (const c of report.components) {
+      if (!isNew(c.line)) continue;
+      if (c.suggestion) {
+        fixes.push({ file: f.path, line: c.line, what: c.name, use: c.suggestion });
+        continue;
+      }
+      if (c.kind !== "foreign") continue;
+      const e = foreign.get(c.name) ?? { finding: c, hits: [] };
+      e.hits.push({ file: f.path, line: c.line });
+      foreign.set(c.name, e);
+    }
+  }
+  const where2 = (hits) => hits.slice(0, 5).map((h) => ({ file: h.file, line: h.line }));
+  const pieces = [];
+  for (const v of variants.values()) {
+    const values = [];
+    for (const h of v.hits) {
+      const pv = { category: h.finding.category, ...h.finding.property ? { property: h.finding.property } : {}, value: h.finding.value };
+      if (!values.some((x) => x.category === pv.category && x.property === pv.property && norm2(x) === norm2(pv))) values.push(pv);
+    }
+    const aspect = aspectOf(values);
+    const bg = v.hits.find((h) => /background/.test(h.finding.property ?? ""))?.finding.suggestion;
+    const nearest = nearestOf(bg ?? v.hits.find((h) => h.finding.suggestion)?.finding.suggestion);
+    const shown = values.map((x) => `${x.property ?? x.category} ${x.value}`).join(", ");
+    pieces.push({
+      id: pieceId([v.component, v.name, aspect]),
+      kind: "variant",
+      title: `${v.component}: ${v.name} ${aspect}`,
+      summary: `${v.component} restyled by hand (${shown}).${nearest ? ` ${nearest.level === "high" ? "It looks a lot like" : "The closest in the library is"} ${nearest.label}.` : ""}`,
+      name: v.name,
+      component: v.component,
+      aspect,
+      values,
+      ...nearest ? { nearest } : {},
+      where: where2(v.hits)
+    });
+  }
+  for (const [name, e] of foreign) {
+    pieces.push({
+      id: pieceId(["component", name]),
+      kind: "component",
+      title: `New component: ${name}`,
+      summary: `${name} comes from ${e.finding.library}, and the library has nothing like it.`,
+      name,
+      component: name.split(".").pop(),
+      values: [],
+      where: where2(e.hits)
+    });
+  }
+  for (const t of tokens.values()) {
+    const nearest = nearestOf(t.hits[0].finding.suggestion);
+    const pname = t.name ?? `${t.category === "color" ? "custom" : t.category}`;
+    const path = proposedTokenPath(nearest?.token, pname, t.category);
+    const tokenFiles = nearest && input.set ? [...new Set(input.set.defs.filter((d) => d.path === nearest.token).map((d) => d.file))] : [];
+    const n = t.hits.length;
+    pieces.push({
+      id: pieceId([t.category, t.name ?? t.value.replace(/^#/, "")]),
+      kind: "token",
+      title: valueTitle(t.category, t.value),
+      summary: `Written by hand in ${n === 1 ? "one place" : `${n} places`}.${nearest ? ` ${nearest.level === "high" ? "It looks a lot like" : "The closest in the library is"} ${nearest.label} (${nearest.value}).` : " The library has nothing close."}`,
+      name: pname,
+      values: [{ category: t.category, ...t.hits[0].finding.property ? { property: t.hits[0].finding.property } : {}, value: t.value }],
+      ...nearest ? { nearest } : {},
+      where: where2(t.hits),
+      token: { path, type: TOKEN_TYPE[t.category] ?? "dimension", value: t.value, files: tokenFiles }
+    });
+  }
+  const order = { variant: 0, component: 1, token: 2 };
+  const seen = /* @__PURE__ */ new Set();
+  const out = pieces.sort((a, b) => order[a.kind] - order[b.kind]).map((p) => {
+    let id = p.id;
+    for (let i = 2; seen.has(id); i++) id = `${p.id}-${i}`;
+    seen.add(id);
+    return id === p.id ? p : { ...p, id };
+  });
+  return { pieces: out, fixes, files: files.length };
+}
+
 // src/audit.ts
 var PROPERTY_HINTS = [
   [/^(color|fill|stroke)$/, /(^|\.)(text|fg|icon|foreground|link)(\.|-|$)/],
@@ -7523,8 +9165,8 @@ function auditSnippet(set, code2, max = 3) {
   });
   const rank2 = (tier) => tier === "semantic" ? 0 : tier === "component" ? 1 : tier === "density" ? 2 : tier === "brand" ? 3 : 4;
   const findings = [];
-  const lines = code2.split("\n");
-  lines.forEach((line, i) => {
+  const lines2 = code2.split("\n");
+  lines2.forEach((line, i) => {
     if (/var\(--/.test(line) && !/#[0-9a-f]{3,8}\b|\d(px|rem|ms)\b/i.test(line.replace(/var\([^)]*\)/g, ""))) return;
     const stripped = line.replace(/var\([^)]*\)/g, "");
     const propAt = (idx) => /([a-zA-Z-]+)['"]?\s*:[^;:,{]*$/.exec(stripped.slice(0, idx))?.[1]?.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`).toLowerCase();
@@ -7592,17 +9234,17 @@ function auditSnippet(set, code2, max = 3) {
 // src/markdown.ts
 var slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 function sections(md) {
-  const lines = md.split("\n");
+  const lines2 = md.split("\n");
   const heads = [];
   let fence = false;
-  lines.forEach((l, i) => {
+  lines2.forEach((l, i) => {
     if (/^\s*(```|~~~)/.test(l)) fence = !fence;
     const m = !fence && /^(#{1,4})\s+(.+?)\s*#*\s*$/.exec(l);
     if (m) heads.push({ level: m[1].length, title: m[2], line: i });
   });
   return heads.map((h, i) => {
     const next = heads.slice(i + 1).find((x) => x.level <= h.level);
-    return { level: h.level, title: h.title, slug: slug(h.title), body: lines.slice(h.line, next ? next.line : lines.length).join("\n").trim() };
+    return { level: h.level, title: h.title, slug: slug(h.title), body: lines2.slice(h.line, next ? next.line : lines2.length).join("\n").trim() };
   });
 }
 function toc(md) {
@@ -7634,6 +9276,7 @@ __export(explorations_exports, {
   installOf: () => installOf,
   listExplorations: () => listExplorations,
   promoteExploration: () => promoteExploration,
+  settingsOf: () => settingsOf,
   startExploration: () => startExploration,
   toExplorationBranch: () => toExplorationBranch,
   writeToExploration: () => writeToExploration
@@ -7658,13 +9301,16 @@ __export(branches_exports, {
   listProducts: () => listProducts,
   mergeBranch: () => mergeBranch,
   productMarks: () => productMarks,
+  reader: () => reader,
   reopenBranch: () => reopenBranch,
   resolveProduct: () => resolveProduct,
   reviewBranch: () => reviewBranch,
   sendForReview: () => sendForReview,
   tryBranch: () => tryBranch,
   updateFromMain: () => updateFromMain,
-  whatNeedsMe: () => whatNeedsMe
+  viewerOf: () => viewerOf,
+  whatNeedsMe: () => whatNeedsMe,
+  writer: () => writer
 });
 import { relative as relative2 } from "node:path";
 var RIGHTS = {
@@ -7976,11 +9622,11 @@ async function commentOnBranch(ctx, a) {
 async function listComments(ctx, a) {
   const n = branchNumber(a.pr);
   const gh = await reader(ctx);
-  const [conversation, lines] = await Promise.all([gh.listIssueComments(n), gh.listReviewComments(n).catch(() => [])]);
+  const [conversation, lines2] = await Promise.all([gh.listIssueComments(n), gh.listReviewComments(n).catch(() => [])]);
   return {
     pr: n,
     conversation: conversation.filter((c) => !c.body.includes("<!-- bridge-branch-preview -->")).map((c) => ({ id: c.id, author: c.author, body: c.body, at: c.updatedAt })),
-    threads: lines.filter((c) => !c.inReplyTo).map((c) => ({ id: c.id, author: c.author, file: c.path, line: c.line, body: c.body, url: c.url, replies: lines.filter((r) => r.inReplyTo === c.id).map((r) => ({ id: r.id, author: r.author, body: r.body })) })),
+    threads: lines2.filter((c) => !c.inReplyTo).map((c) => ({ id: c.id, author: c.author, file: c.path, line: c.line, body: c.body, url: c.url, replies: lines2.filter((r) => r.inReplyTo === c.id).map((r) => ({ id: r.id, author: r.author, body: r.body })) })),
     howToReply: "bridge_comment with replyTo: the thread id."
   };
 }
@@ -8432,7 +10078,7 @@ async function checkContrast(ctx, a) {
   const delta2 = core.contrastDelta(beforeRes, afterRes);
   return { ...base, edits: a.edits.length, notes, changed: delta2, newFailures: delta2.filter((d) => d.passBefore && !d.passAfter) };
 }
-var issueKey2 = (i) => `${i.code}|${i.path ?? ""}|${i.file ?? ""}|${i.message}`;
+var issueKey3 = (i) => `${i.code}|${i.path ?? ""}|${i.file ?? ""}|${i.message}`;
 async function validateTokens(ctx, a) {
   const { before, after, notes } = await withEdits(ctx, a.edits);
   const issues = core.validate(after);
@@ -8448,8 +10094,8 @@ async function validateTokens(ctx, a) {
     ...a.includeWarnings ? { warnings } : warnings.length ? { warningSample: warnings.slice(0, 5) } : {}
   };
   if (!a.edits?.length) return res;
-  const prev = new Set(core.validate(before).map(issueKey2));
-  return { ...res, notes, newErrors: errors.filter((i) => !prev.has(issueKey2(i))) };
+  const prev = new Set(core.validate(before).map(issueKey3));
+  return { ...res, notes, newErrors: errors.filter((i) => !prev.has(issueKey3(i))) };
 }
 async function listComponentsOp(ctx, a) {
   const { config } = await ctx.config();
@@ -8602,25 +10248,13 @@ async function proposeTokenChange(ctx, a) {
   const target = a.branch ? await explorationContext(ctx, a.branch, { requireCheckout: !a.dryRun }) : null;
   if (target) ctx = target.ctx;
   const { config } = await ctx.config();
-  const { before, after, touched, notes } = await withEdits(ctx, a.edits);
-  const changes = core.diff(before, after);
-  if (!changes.length) return { status: "no-change", message: "The edits leave every token as it was." };
-  const prevErrors = new Set(core.validate(before).map(issueKey2));
-  const newErrors = core.validate(after).filter((i) => i.level === "error" && !prevErrors.has(issueKey2(i)));
+  const before = await ctx.tokens();
   const pairs = await core.readContrastPairs(ctx.source, config).catch(() => []);
-  const delta2 = pairs.length ? core.contrastDelta(core.runContrast(before, pairs, config.contrast?.modes), core.runContrast(after, pairs, config.contrast?.modes)) : [];
-  const newFailures = delta2.filter((d) => d.passBefore && !d.passAfter);
-  const imp = core.impact(before, after, changes);
-  const tier = core.classify(changes, [], config);
-  const summary2 = a.summary?.trim() || a.title;
   const marks = productMarks(productsOf(config), product);
-  const body = [core.prBody({ summary: summary2, changes, contrast: delta2, impact: imp, tier, validationErrors: newErrors.length, tool: "Bridge MCP" }), marks.line].filter(Boolean).join("\n\n");
-  const slugTitle = core.slugify(a.title);
-  const changesetPath = `${config.changesets?.dir ?? ".changeset"}/bridge-${slugTitle}.md`;
-  const files = [
-    ...touched.map((f) => ({ path: prefixPath(after, f), content: after.files.get(f) })),
-    ...config.changesets ? [{ path: changesetPath, content: core.changeset(config.changesets.package, tier.bump, summary2) }] : []
-  ];
+  const plan = planTokenProposal({ before, pairs, edits: a.edits, title: a.title, summary: a.summary, config, tool: "Bridge MCP", bodyExtra: [marks.line] });
+  if (!plan) return { status: "no-change", message: "The edits leave every token as it was." };
+  const { after, changes, tier, contrast: delta2, newFailures, newErrors, impact: imp, notes, files, body, slug: slugTitle } = plan;
+  const summary2 = plan.summary;
   const report = {
     title: a.title,
     tier: tier.tier,
@@ -8669,15 +10303,12 @@ Tier ${tier.tier}. Proposed through Bridge MCP (source: mcp).`;
   }
   const gh = await ctx.github();
   if (!ctx.canWriteRemote) return { status: "preview", message: "Read-only: set GITHUB_TOKEN to open this as a pull request.", ...preview, fileContents: files };
-  const commitMsg = `feat(tokens): ${a.title}
-
-Proposed through Bridge MCP (source: mcp). Tier ${tier.tier}.`;
   const base = ctx.ref ?? baseBranchOf(config);
-  for (let i = 2; await gh.getBranchSha(branch).then(Boolean, () => false); i++) branch = branchWithJiraKey(`${config.governance.branchPrefix}${slugTitle}-${i}`, jira);
-  const commit = await gh.commitToNewBranch({ base, branch, message: commitMsg, files });
-  const labels = [...config.governance.labels, `tier: ${tier.tier}`, ...tier.tier === 3 ? ["tokens"] : [], ...tier.bump === "major" ? ["breaking"] : [], ...marks.labels];
-  const pr = await gh.createPullRequest({ base, head: branch, title: titleWithJiraKey(`feat(tokens): ${a.title}`, jira), body, draft: tier.tier >= 2 });
-  await gh.addLabels(pr.number, labels);
+  const opened = await writeTokenProposalOnGitHub(gh, plan, { base, branchPrefix: config.governance.branchPrefix, jira, labels: config.governance.labels, labelsAfter: marks.labels, tool: "Bridge MCP (source: mcp)" });
+  branch = opened.branch;
+  const commit = { sha: opened.commit };
+  const pr = { number: opened.pr, url: opened.url };
+  const labels = opened.labels;
   return { status: "pr-opened", ...preview, branch, commit: commit.sha, pr: pr.number, url: pr.url, labels, draft: tier.tier >= 2, product: product.name };
 }
 async function addToBranch(ctx, a) {
@@ -8688,8 +10319,8 @@ async function addToBranch(ctx, a) {
   const { before, after, touched, notes } = await withEdits(at, a.edits);
   const changes = core.diff(before, after);
   if (!changes.length) return { status: "no-change", pr: n, message: `#${n} already has these values.` };
-  const prevErrors = new Set(core.validate(before).map(issueKey2));
-  const newErrors = core.validate(after).filter((i) => i.level === "error" && !prevErrors.has(issueKey2(i)));
+  const prevErrors = new Set(core.validate(before).map(issueKey3));
+  const newErrors = core.validate(after).filter((i) => i.level === "error" && !prevErrors.has(issueKey3(i)));
   const pairs = await core.readContrastPairs(at.source, config).catch(() => []);
   const delta2 = pairs.length ? core.contrastDelta(core.runContrast(before, pairs, config.contrast?.modes), core.runContrast(after, pairs, config.contrast?.modes)) : [];
   const newFailures = delta2.filter((d) => d.passBefore && !d.passAfter);
@@ -8786,7 +10417,7 @@ async function getReview(ctx, a) {
   const changes = core.diff(before, after);
   const pairs = await core.readContrastPairs(headSrc, config).catch(() => []);
   const delta2 = pairs.length ? core.contrastDelta(core.runContrast(before, pairs, config.contrast?.modes), core.runContrast(after, pairs, config.contrast?.modes)) : [];
-  const prevErrors = new Set(core.validate(before).map(issueKey2));
+  const prevErrors = new Set(core.validate(before).map(issueKey3));
   const errors = core.validate(after).filter((i) => i.level === "error");
   const tokenRoot = config.tokens.root.replace(/\/$/, "");
   const otherFiles = changedFiles.filter((f) => !f.startsWith(`${tokenRoot}/`) && !f.startsWith(`${config.changesets?.dir ?? ".changeset"}/`));
@@ -8804,7 +10435,7 @@ async function getReview(ctx, a) {
     diffTable: core.tokenTable(changes.map((c) => ({ ...c, file: prefixPath(after, c.file) }))),
     contrastTable: core.contrastTable(delta2),
     contrastNewFailures: delta2.filter((d) => d.passBefore && !d.passAfter).length,
-    validation: { errors: errors.length, newErrors: errors.filter((i) => !prevErrors.has(issueKey2(i))) },
+    validation: { errors: errors.length, newErrors: errors.filter((i) => !prevErrors.has(issueKey3(i))) },
     impact: imp
   };
 }
@@ -8864,7 +10495,7 @@ async function visualImpact(ctx, a, run2) {
   if (ctx.mode !== "local" || !ctx.root) throw new Error("Visual impact needs a local checkout (start Bridge with --root): it builds Storybook and the app at both refs.");
   if (!ctx.isGit) throw new Error(`${ctx.root} is not a git repository.`);
   const out = a.out ? resolve3(ctx.root, a.out) : join4(ctx.root, "visual-impact");
-  const runImpact = run2 ?? (await import("./src-DHJOM5PQ.js")).runImpact;
+  const runImpact = run2 ?? (await import("./src-F2PTXW5B.js")).runImpact;
   const r = await runImpact({
     root: ctx.root,
     base: a.base ?? "main",
@@ -9327,15 +10958,15 @@ function requestFromIssue(issue) {
   const parsed = parseRequestIssue(issue.body);
   if (parsed) return parsed;
   const m = /^\s*([^:]{1,60}):\s*(.+)$/.exec(issue.title);
-  const kindLabel2 = issue.labels.map((l) => /^request:\s*(.+)$/.exec(l)?.[1]?.trim()).find((k) => k && KINDS2.has(k));
-  const sourceLabel2 = issue.labels.map((l) => /^source:\s*(.+)$/.exec(l)?.[1]?.trim()).find((s) => s === "figma" || s === "studio" || s === "cli" || s === "mcp");
+  const kindLabel3 = issue.labels.map((l) => /^request:\s*(.+)$/.exec(l)?.[1]?.trim()).find((k) => k && KINDS2.has(k));
+  const sourceLabel3 = issue.labels.map((l) => /^source:\s*(.+)$/.exec(l)?.[1]?.trim()).find((s) => s === "figma" || s === "studio" || s === "cli" || s === "mcp");
   return {
     component: m ? m[1].trim() : "Unknown",
-    kind: kindLabel2 ?? "other",
+    kind: kindLabel3 ?? "other",
     title: m ? m[2].trim() : issue.title,
     summary: issue.body.trim() || issue.title,
     changes: [],
-    source: sourceLabel2 ?? "studio"
+    source: sourceLabel3 ?? "studio"
   };
 }
 function statusOf(issue, prs) {
@@ -9632,8 +11263,232 @@ async function figmaCoverage(ctx, a = {}) {
   };
 }
 
+// src/pieces.ts
+var pieces_exports = {};
+__export(pieces_exports, {
+  missingPiecesOp: () => missingPiecesOp,
+  openLibraryBranchOp: () => openLibraryBranchOp,
+  productBranchOp: () => productBranchOp,
+  switchToPublishedOp: () => switchToPublishedOp,
+  useLibraryPreviewOp: () => useLibraryPreviewOp
+});
+var NEED = "Contents, Pull requests and Issues: read and write";
+var short = (p) => ({
+  id: p.id,
+  kind: p.kind,
+  title: p.title,
+  summary: p.summary,
+  ...p.component ? { component: p.component } : {},
+  ...p.nearest ? { nearest: `${p.nearest.label} (${p.nearest.token}, ${p.nearest.value})` } : {},
+  ...p.token ? { token: p.token.path } : {},
+  where: p.where.map((w) => `${w.file}:${w.line}`),
+  opens: p.kind === "token" ? "a token change" : p.kind === "variant" ? "a library exploration" : "a component request"
+});
+async function missingPiecesOp(ctx, a) {
+  const n = branchNumber(a.pr);
+  const gh = a.record ? await writer(ctx, "Recording the missing pieces", NEED) : await reader(ctx);
+  const { config } = await ctx.config();
+  const read = await readProductBranchOnGitHub(gh, n, { products: productsOf(config) });
+  const [ds, set] = await Promise.all([designSystemIndex(ctx), ctx.tokens()]);
+  const r = missingPieces({ files: read.files, ds, set });
+  const recorded = a.record ? await recordPiecesOnGitHub(gh, n, { pieces: r.pieces, fixes: r.fixes.length, headSha: read.pull.headSha }) : null;
+  const linked = recorded?.links ?? read.record?.links ?? [];
+  return {
+    pr: n,
+    branch: read.pull.headRef,
+    product: read.product.name,
+    files: r.files,
+    ...read.skipped ? { skipped: `${read.skipped} more product files were not read (limit ${r.files}).` } : {},
+    pieces: r.pieces.map((p) => ({ ...short(p), ...linked.some((l) => l.piece === p.id) ? { linked: linked.find((l) => l.piece === p.id).number } : {} })),
+    fixes: { count: r.fixes.length, sample: r.fixes.slice(0, 10).map((f) => `${f.file}:${f.line} ${f.what} -> use ${f.use}`) },
+    recorded: Boolean(recorded),
+    next: r.pieces.length ? `${a.record ? "" : "Record them (record: true) so Studio shows them, then "}open a library branch for each with bridge_open_library_branch { pr: ${n}, piece: "<id>" }. Fixes are values and components the library already has: use them in the product code instead.` : "Nothing is missing from the library. Fix the values that equal a token, if any."
+  };
+}
+function tokenWriter(ctx, gh, source) {
+  return async (plan) => {
+    const { config } = await ctx.config();
+    const [before, pairs] = await Promise.all([ctx.tokens(), core.readContrastPairs(ctx.source, config).catch(() => [])]);
+    const p = planTokenProposal({ before, pairs, edits: plan.edits, title: plan.title, summary: plan.summary, config, tool: source === "mcp" ? "Bridge MCP" : "the bridge CLI" });
+    if (!p) throw new Error("The token already exists with that value: nothing to add.");
+    if (p.blocked) throw new Error(`The library branch was not opened: ${p.blocked}. Change the value (bridge_propose_token_change with dryRun shows why).`);
+    const opened = await writeTokenProposalOnGitHub(gh, p, { base: baseBranchOf(config), branchPrefix: config.governance.branchPrefix, labels: config.governance.labels, labelsAfter: [NEEDED_BY_LABEL], tool: source === "mcp" ? "Bridge MCP (source: mcp)" : "the bridge CLI" });
+    return { number: opened.pr, url: opened.url, branch: opened.branch };
+  };
+}
+async function openLibraryBranchOp(ctx, a) {
+  const n = branchNumber(a.pr);
+  const source = a.source ?? "mcp";
+  const gh = a.dryRun ? await reader(ctx) : await writer(ctx, "Opening a library branch", NEED);
+  const { config } = await ctx.config();
+  const viewer = await viewerOf(ctx, gh);
+  const s = settingsOf(config);
+  const r = await openLibraryBranchOnGitHub(gh, {
+    pr: n,
+    piece: a.piece,
+    base: s.base,
+    products: productsOf(config),
+    exploration: { packages: s.packages, apps: s.apps },
+    writeTokens: tokenWriter(ctx, gh, source),
+    ...viewer ? { openedBy: viewer } : {},
+    ...source === "mcp" ? { agent: "claude" } : {},
+    source,
+    usePreview: a.usePreview,
+    dryRun: a.dryRun
+  });
+  const plan = r.plan;
+  const what = plan.kind === "token-change" ? "token change" : plan.kind === "exploration" ? "library exploration" : "component request";
+  const next = r.status === "dry-run" ? `Run it without dryRun to open the ${what}.` : plan.kind === "exploration" ? `Build it on ${r.link?.branch}: ${plan.brief} Then bridge_use_library_preview { pr: ${n}, piece: "${a.piece}" } so the product branch shows it.` : plan.kind === "request" ? "A person or Claude builds the component from the request (bridge_get_request). The product branch keeps its own version until it ships." : r.preview?.status === "conflict" ? r.preview.said : "Design and tech owners review the token change. Once it ships, bridge_switch_to_published moves the product branch to the real version.";
+  return {
+    status: r.status,
+    pr: n,
+    piece: a.piece,
+    opens: what,
+    title: plan.title,
+    ...plan.kind === "token-change" ? { edits: plan.edits } : {},
+    ...plan.kind === "exploration" ? { exploration: plan.exploration.name, brief: plan.brief } : {},
+    ...plan.kind === "request" ? { request: plan.request.title } : {},
+    neededBy: `${plan.neededBy.title} (#${plan.neededBy.pr}) in ${plan.neededBy.productName}`,
+    ...r.link ? { library: { kind: r.link.kind, number: r.link.number, url: r.link.url, ...r.link.branch ? { branch: r.link.branch } : {} } } : {},
+    ...r.preview ? { preview: r.preview } : {},
+    ...r.warnings.length ? { warnings: r.warnings } : {},
+    next
+  };
+}
+async function productBranchOp(ctx, a) {
+  const n = branchNumber(a.pr);
+  const gh = await reader(ctx);
+  const { config } = await ctx.config();
+  const viewer = await viewerOf(ctx, gh);
+  const v = await productBranchViewOnGitHub(gh, n, { products: productsOf(config), viewer });
+  return {
+    pr: n,
+    title: v.pull.title,
+    product: v.product.name,
+    said: `${v.sentence.lead}${v.sentence.strong}${v.sentence.rest}`,
+    checked: v.record ? v.record.checkedAt : null,
+    linked: v.linked.map((l) => ({
+      piece: l.piece?.title ?? l.link.piece,
+      library: { kind: l.link.kind, number: l.link.number, url: l.link.url },
+      status: l.status.line,
+      preview: l.preview.sentence,
+      ...l.preview.action ? { action: l.preview.action.label, tool: l.preview.action.kind === "switch" ? `bridge_switch_to_published { pr: ${n} }` : `bridge_use_library_preview { pr: ${n}, piece: "${l.link.piece}" }` } : {}
+    })),
+    notLinked: v.open.map(short),
+    ...v.record ? {} : { next: `Find its missing pieces: bridge_missing_pieces { pr: ${n}, record: true }.` }
+  };
+}
+async function useLibraryPreviewOp(ctx, a) {
+  const n = branchNumber(a.pr);
+  const gh = await writer(ctx, "Using a library preview", "Contents: read and write");
+  const { config } = await ctx.config();
+  const v = await productBranchViewOnGitHub(gh, n, { products: productsOf(config) });
+  const l = v.linked.find((x) => x.link.piece === a.piece);
+  if (!l) throw new Error(`No library branch for "${a.piece}" on #${n}. Open one first: bridge_open_library_branch.`);
+  if (l.link.kind === "request" || !l.link.branch) throw new Error(`"${l.link.title}" is a request: there is nothing to preview until it is built.`);
+  if (l.status.key === "shipped") throw new Error("The library already shipped it: use bridge_switch_to_published instead.");
+  if (l.status.key === "closed") throw new Error("The library branch is closed: there is nothing to preview.");
+  const r = await useLibraryPreviewOnGitHub(gh, { productBranch: v.pull.headRef, libraryBranch: l.link.branch, libraryNumber: l.link.number });
+  return { pr: n, piece: a.piece, library: l.link.number, ...r };
+}
+async function switchToPublishedOp(ctx, a) {
+  const n = branchNumber(a.pr);
+  const gh = await writer(ctx, "Switching to the published version", "Contents and Pull requests: read and write");
+  return { pr: n, ...await switchToPublishedOnGitHub(gh, n) };
+}
+
+// src/figma.ts
+var figma_exports = {};
+__export(figma_exports, {
+  figmaChangesOp: () => figmaChangesOp,
+  getFigmaChangeOp: () => getFigmaChangeOp,
+  markFigmaDraftedOp: () => markFigmaDraftedOp,
+  pushFigmaComponentOp: () => pushFigmaComponentOp
+});
+var NEED2 = "Contents and Pull requests: read and write";
+async function tokenFacts(ctx, set, component) {
+  const { config } = await ctx.config();
+  const text = await ctx.source.read(config.components?.specs ?? DEFAULT_COMPONENT_SPECS_FILE).catch(() => void 0);
+  const usage = text ? specsUsage(parseComponentSpecs(text), component) : () => ({ variants: [], components: [] });
+  return { tierOf: (p) => set.tierOf(p), usedElsewhere: usage };
+}
+async function figmaChangesOp(ctx, a = {}) {
+  const gh = await reader(ctx);
+  const rows = await listFigmaChangesOnGitHub(gh, { state: a.state ?? "open" });
+  return {
+    changes: rows.map((r) => ({ pr: r.number, title: r.title, url: r.url, branch: r.branch, component: r.origin.component, route: r.origin.route === "token-change" ? "exact token change" : "Claude AI drafts", status: r.status.label, said: r.status.sentence })),
+    next: rows.some((r) => r.status.key === "waiting-for-claude") ? "Draft one: bridge_get_figma_change { pr } gives the spec and the steps." : rows.length ? "Owners review them on GitHub or in Bridge Studio." : "Nothing sent from Figma is open."
+  };
+}
+async function getFigmaChangeOp(ctx, a) {
+  const n = branchNumber(a.pr);
+  const gh = await reader(ctx);
+  const { config } = await ctx.config();
+  const r = await figmaChangeOnGitHub(gh, n, { componentsDir: config.components?.dir });
+  return {
+    pr: n,
+    title: r.pull.title,
+    url: r.pull.url,
+    branch: r.pull.headRef,
+    component: r.origin.component,
+    route: r.origin.route === "token-change" ? "exact token change" : "Claude AI drafts",
+    status: r.status.label,
+    said: r.status.sentence,
+    ...r.spec ? { spec: { path: r.origin.spec, changes: r.spec.changes, variantAxes: r.spec.variantAxes, properties: r.spec.properties, tokenEdits: r.spec.tokenEdits ?? [], reasons: r.spec.reasons ?? [] } } : {},
+    ...r.brief ? { brief: r.brief } : {},
+    next: r.brief && r.status.key === "waiting-for-claude" ? "Follow the brief, push the code to the branch, then bridge_mark_figma_change_drafted." : r.status.sentence
+  };
+}
+async function markFigmaDraftedOp(ctx, a) {
+  const n = branchNumber(a.pr);
+  const gh = await writer(ctx, "Marking a Figma change drafted", NEED2);
+  const r = await markFigmaChangeDraftedOnGitHub(gh, n);
+  return { pr: n, status: r.status.label, said: r.status.sentence, files: r.files, next: "Send it for review when it is ready (bridge_send_for_review), or tell the designer it is ready to look at." };
+}
+async function pushFigmaComponentOp(ctx, a) {
+  const d = a.diff;
+  if (!d || d.v !== 1 || typeof d.component !== "string" || !Array.isArray(d.changes)) throw new Error("The diff is not a Bridge component diff (v 1): see the spec of a branch from bridge_get_figma_change for its shape.");
+  const source = a.source ?? "mcp";
+  const tool = source === "mcp" ? "Bridge MCP" : "the bridge CLI";
+  const { config } = await ctx.config();
+  const set = await ctx.tokens();
+  const tokens = await tokenFacts(ctx, set, d.component);
+  const gh = a.dryRun ? await reader(ctx) : await writer(ctx, "Sending a component change from Figma", NEED2);
+  const pairs = await core.readContrastPairs(ctx.source, config).catch(() => []);
+  const aliasOfPath = (p) => aliasOf(set.defsOf(p)[0]?.value) ?? void 0;
+  const r = await openComponentPushOnGitHub(gh, {
+    diff: { ...d, source: d.source ?? source },
+    tokens,
+    base: baseBranchOf(config),
+    branchPrefix: config.governance.branchPrefix,
+    labels: [...config.governance.labels, `source: ${source}`],
+    tool,
+    dryRun: a.dryRun,
+    writeTokens: async ({ edits, title, summary: summary2, bodyExtra }) => {
+      const all = [...pairs, ...componentContrastPairs(edits, pairs, { aliasOf: aliasOfPath, paths: set.allPaths() })];
+      const p = planTokenProposal({ before: set, pairs: all, edits, title, summary: summary2, config, tool, bodyExtra });
+      if (!p) throw new Error("The library already paints it this way: nothing to send.");
+      if (p.blocked) throw new Error(`Not sent: ${p.blocked}. Pick another variable.`);
+      const opened = await writeTokenProposalOnGitHub(gh, p, { base: baseBranchOf(config), branchPrefix: config.governance.branchPrefix, labels: config.governance.labels, labelsAfter: [`source: ${source}`], tool: `${tool} (source: ${source})` });
+      return { number: opened.pr, url: opened.url, branch: opened.branch };
+    }
+  });
+  const plan = r.plan;
+  return {
+    status: r.status,
+    component: d.component,
+    route: plan.route === "token-change" ? "exact token change" : plan.route === "claude-draft" ? "Claude AI drafts" : "fix in Figma",
+    said: plan.said,
+    ...plan.edits.length ? { edits: plan.edits } : {},
+    ...plan.reasons.length ? { reasons: plan.reasons } : {},
+    ...plan.issues.length ? { fixInFigma: plan.issues } : {},
+    ...r.link ? { library: r.link } : {},
+    next: r.status === "dry-run" ? "Run it without dryRun to open the library branch." : r.status === "not-sent" ? "Nothing was sent: fix these in Figma, then push again." : plan.route === "claude-draft" ? `Draft the code: bridge_get_figma_change { pr: ${r.link.number} }.` : "Design and tech owners review the token change. Once it ships, a pull in the DS Bridge plugin rebuilds the component."
+  };
+}
+
 // src/server.ts
-var VERSION = true ? "0.4.1" : "dev";
+var VERSION = true ? "0.6.0" : "dev";
 var ok = (data) => ({ content: [{ type: "text", text: typeof data === "string" ? data : JSON.stringify(data, null, 2) }] });
 var fail = (e) => ({ content: [{ type: "text", text: `Error: ${e.message ?? String(e)}` }], isError: true });
 var run = (fn) => async (a) => {
@@ -9673,6 +11528,8 @@ function createServer(ctx) {
         `Change texts from Figma and docs from Bridge Studio: when the user says "${DRAFT_PHRASE}" (or asks you to draft their Bridge changes or docs), call bridge_pending_drafts. For change items, look at the before and after images and write each title, summary and change line in the Bridge voice. For docs items (scope "docs"), follow the brief: write only the sections it asks for, grounded in the props, CSS module classes and source it quotes, never an invented prop or behavior, never anatomy. Then call bridge_write_drafts. The designer reviews them in the DS Bridge Figma plugin or on the Library page.`,
         "Studio parity: a designer can do in Claude what they do in Bridge Studio. Branches in review: bridge_what_needs_me (the queue), bridge_branch_status, bridge_send_for_review, bridge_back_to_draft, bridge_review_branch, bridge_ask_someone_else, bridge_comment, bridge_update_from_main (token conflicts too), bridge_try_branch (try it in a product, share it), bridge_combine_branches, bridge_close_branch, bridge_reopen_branch, bridge_merge_branch (same gate as Studio, owner override with a reason). Docs: bridge_save_docs. Writes act under the person's GitHub token: only do them when the person asked, and merge only when they explicitly asked to merge.",
         'Products: work starts for a product (bridge_list_products). Tools that start work take "product"; without it Bridge uses the product of the current folder or repo. Ask the person when it is not obvious.',
+        "Product branches and the library: when a designer explores a product feature with you (an exploration for a product), check it with bridge_missing_pieces (record: true) before they share it; for each piece the library lacks, offer bridge_open_library_branch, which opens the library side linked to their branch. bridge_product_branch says where each library branch stands; bridge_switch_to_published moves the product branch to the real version once the library ships.",
+        "Components from Figma: the DS Bridge plugin sends a component changed in Figma to a library branch. Token swaps go as exact token changes; new variants, properties and components go to a branch carrying the spec, waiting for Claude AI. When the person asks you to draft one, bridge_figma_changes lists them and bridge_get_figma_change gives the spec and the steps; write the code on that branch, push it, then bridge_mark_figma_change_drafted. Never claim a branch is drafted before its code is pushed.",
         'Explorations try experimental variables and components in a product staging branch without touching main: an explore/<slug> branch with a draft pull request labeled exploration, previews and a snapshot package. bridge_start_exploration starts one, bridge_list_explorations lists them. To work on one, pass "branch": "explore/<slug>" to bridge_propose_token_change, bridge_draft_docs and bridge_get_request, and never open a pull request to main from it: a person promotes it to review or closes it.'
       ].join(" ")
     }
@@ -10170,6 +12027,97 @@ function createServer(ctx) {
   const Pr = z.union([z.number().int().positive(), z.string().min(1)]).describe('The branch number Studio shows (12 or "#12"), or its GitHub link.');
   const WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true };
   const READ = { readOnlyHint: true, openWorldHint: true };
+  const Piece = z.string().min(1).describe('The piece id bridge_missing_pieces returned ("badge-overdue-tone").');
+  server.registerTool(
+    "bridge_missing_pieces",
+    {
+      title: "Find what a product branch adds outside the library",
+      description: 'Check a product branch (an exploration started for a product) against the library: the adoption audit on each product file it changes, at its start and at its head, keeps what the branch added. New hardcoded values become token pieces beside the closest token, values written on a library component become a variant of it ("Badge: overdue tone"), components from another UI library with no library equivalent become new components. Values equal to a token and components the library has are fixes, not pieces. With record: true, saves the result in the branch description, where Bridge Studio shows it (needs GITHUB_TOKEN, pull requests: write). Run it when a designer finishes exploring with you, then offer to open a library branch for each piece.',
+      inputSchema: { pr: Pr, record: z.boolean().optional().describe("Save the pieces in the product branch description (Studio reads them there). Keeps the library branches already opened.") },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    run((a) => missingPiecesOp(ctx, a))
+  );
+  server.registerTool(
+    "bridge_open_library_branch",
+    {
+      title: "Open a library branch for a missing piece",
+      description: 'Turn one recorded missing piece into a library branch linked to the product branch, as Bridge Studio does: a token piece opens a token change (same gate and body as bridge_propose_token_change, a draft for design and tech review) and the product branch takes its preview; a variant opens a library exploration with the brief to build it (build it there, then bridge_use_library_preview); a new component opens a component request. Both sides link: the library side says "Needed by" the product branch (label needed-by-product), the product branch records it. Needs GITHUB_TOKEN (contents, pull requests and issues: write). dryRun shows what it would open. Only when the person asked.',
+      inputSchema: { pr: Pr, piece: Piece, usePreview: z.boolean().optional().describe("Merge the new library branch into the product branch when it already changes something (default true)."), dryRun: z.boolean().optional() },
+      annotations: WRITE
+    },
+    run((a) => openLibraryBranchOp(ctx, { ...a, source: "mcp" }))
+  );
+  server.registerTool(
+    "bridge_product_branch",
+    {
+      title: "Product branch and its library branches",
+      description: "A product branch as Studio shows it: the summary sentence, each linked library branch with its status and reviewers, what its preview means for the product branch and the next action, and the pieces with no library branch yet.",
+      inputSchema: { pr: Pr },
+      annotations: READ
+    },
+    run((a) => productBranchOp(ctx, a))
+  );
+  server.registerTool(
+    "bridge_use_library_preview",
+    {
+      title: "Use a library branch preview in a product branch",
+      description: "The product branch takes the latest commits of the library branch of a piece (Bridge merges it in), so the product preview shows the real library change before it ships. A conflict is left to a developer. Needs GITHUB_TOKEN (contents: write). Only when the person asked.",
+      inputSchema: { pr: Pr, piece: Piece },
+      annotations: WRITE
+    },
+    run((a) => useLibraryPreviewOp(ctx, a))
+  );
+  server.registerTool(
+    "bridge_switch_to_published",
+    {
+      title: "Switch a product branch to the published version",
+      description: "Once its library branches shipped, bring main into the product branch (GitHub update branch): it stops carrying the library change and uses the shipped one. Token conflicts go through bridge_update_from_main. Needs GITHUB_TOKEN (contents and pull requests: write). Only when the person asked.",
+      inputSchema: { pr: Pr },
+      annotations: WRITE
+    },
+    run((a) => switchToPublishedOp(ctx, a))
+  );
+  server.registerTool(
+    "bridge_figma_changes",
+    {
+      title: "Component changes sent from Figma",
+      description: "The library branches the DS Bridge Figma plugin opened for components changed in Figma (label from-figma), with where each stands: an exact token change (no AI, contrast gated), or a branch carrying the spec, waiting for Claude AI to draft the code, then drafted by Claude AI and reviewed by a person.",
+      inputSchema: { state: z.enum(["open", "closed", "all"]).optional().describe("Default open.") },
+      annotations: READ
+    },
+    run((a) => figmaChangesOp(ctx, a))
+  );
+  server.registerTool(
+    "bridge_get_figma_change",
+    {
+      title: "Get a component change from Figma, to draft it",
+      description: "One library branch sent from Figma: its spec (variant matrix, properties, bound variables per variant, layers, what code gave Figma before, the exact token swaps) and the brief to draft the code on that branch. Check out the branch, write the TSX, CSS module, examples, docs and changeset, run npm run specs and the tests, push, then call bridge_mark_figma_change_drafted.",
+      inputSchema: { pr: Pr },
+      annotations: READ
+    },
+    run((a) => getFigmaChangeOp(ctx, a))
+  );
+  server.registerTool(
+    "bridge_mark_figma_change_drafted",
+    {
+      title: "Mark a Figma change drafted by Claude AI",
+      description: "After you pushed the code for a component change from Figma to its branch: label it drafted-by-claude (no longer waiting-for-claude) and say so in its description, for a person to review. Refused while the branch only carries the spec. Needs GITHUB_TOKEN (pull requests: write).",
+      inputSchema: { pr: Pr },
+      annotations: WRITE
+    },
+    run((a) => markFigmaDraftedOp(ctx, a))
+  );
+  server.registerTool(
+    "bridge_push_figma_component",
+    {
+      title: "Send a component change from Figma",
+      description: "What the DS Bridge plugin Push tab does, from a structured diff of a Figma component (the v 1 spec shape: component, figmaName, coded, kind, title, summary, changes, rebinds, needsCode, unknown, variantAxes, properties, bindings, anatomy). An exact token swap on a component token used nowhere else opens a token change (contrast gated, reviewed like any token change); anything that needs code opens a draft branch with the spec, waiting for Claude AI; detached layers, raw values and variables the library lacks are listed with what to do and never sent. dryRun shows the route. Needs GITHUB_TOKEN (contents and pull requests: write). Only when the person asked.",
+      inputSchema: { diff: z.record(z.string(), z.unknown()).describe("The structured component diff (v 1)."), dryRun: z.boolean().optional() },
+      annotations: WRITE
+    },
+    run((a) => pushFigmaComponentOp(ctx, { diff: a.diff, dryRun: a.dryRun, source: "mcp" }))
+  );
   server.registerTool(
     "bridge_list_products",
     {
@@ -10406,8 +12354,8 @@ function createServer(ctx) {
     new ResourceTemplate("bridge://components/{name}", {
       list: async () => {
         const { config } = await ctx.config();
-        const names2 = await listComponentNames(ctx.source, config);
-        return { resources: names2.map((n) => ({ uri: `bridge://components/${n.name}`, name: n.name, mimeType: "application/json" })) };
+        const names3 = await listComponentNames(ctx.source, config);
+        return { resources: names3.map((n) => ({ uri: `bridge://components/${n.name}`, name: n.name, mimeType: "application/json" })) };
       },
       complete: {
         name: async (value) => {
@@ -10595,6 +12543,8 @@ export {
   requests_exports,
   drafts_exports,
   studio_exports,
+  pieces_exports,
+  figma_exports,
   VERSION,
   createServer,
   serveStdio,