@bridge-ds/mcp 0.3.2 → 0.4.0

package/dist/{chunk-MTQCDV65.js → chunk-NYFH322K.js}

@@ -1,7 +1,12 @@
 import {
   CONFIG_FILE,
+  DEFAULT_COMPONENT_SPECS_FILE,
+  DEFAULT_OVERRIDE,
   DEFAULT_PROTECTED_BRANCHES,
   DEFAULT_RIGHTS,
+  DEFAULT_TOKEN_PATHS,
+  FIGMA_REFERENCES_BRANCH,
+  FIGMA_REFERENCES_MANIFEST,
   LayeredTokenSet,
   ProtectedBranchError,
   RISK_LABELS,
@@ -12,6 +17,7 @@ import {
   assertSafeBranch,
   baseBranchOf,
   branchExists,
+  canShip,
   changeTable,
   checkLayeredPair,
   classifyLayered,
@@ -22,11 +28,15 @@ import {
   contrastDelta,
   contrastDeltaTable,
   contrastPair,
+  coverageSummary,
   currentBranch,
+  defaultProduct,
   diffLayered,
   entryLabel,
   expandOwners,
+  figmaCell,
   findPreviewComment,
+  findProduct,
   git,
   globToRegExp,
   hexToRgba,
@@ -36,9 +46,15 @@ import {
   listFilesAt,
   loadConfig,
   originRepo,
+  parseComponentSpecs,
   parseContrastChecks,
   previewLinks,
+  previewUrl,
   previewsSettled,
+  productForPlace,
+  productLabel,
+  productOfBranch,
+  productsOf,
   protectedBranchesOf,
   readPreviewComment,
   renderedColor,
@@ -49,12 +65,14 @@ import {
   selectTokenFiles,
   shipPolicy,
   showFile,
+  threeWayDiff,
   toConfigJson,
   tokensPath,
+  unreadableShipTeams,
   unreadableTeams,
   validateLayered,
   whoCanShipSentence
-} from "./chunk-X455XY4E.js";
+} from "./chunk-7DBLDJIL.js";
 
 // src/lib.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -62,6 +80,12 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 // src/context.ts
 import { resolve as resolve2 } from "node:path";
 
+// ../core/src/types.ts
+var EXT_ID = "com.dsbridge.id";
+var EXT_SCOPES = "com.figma.scopes";
+var PRIMITIVE_MODE = "value";
+var SINGLE_MODE = PRIMITIVE_MODE;
+
 // ../core/src/json-ast.ts
 var JsonParseError = class extends Error {
   constructor(message, offset) {
@@ -319,6 +343,24 @@ function serializeTokenFile(doc) {
 }
 var isTokenNode = (node) => node.kind === "object" && getEntry(node, "$value") !== void 0;
 var isGroupKey = (key) => !key.startsWith("$");
+function flattenTokens(doc) {
+  const out = [];
+  const walk2 = (node, path, inheritedType) => {
+    const ownGroupType = stringEntry(node, "$type");
+    const groupType = ownGroupType ?? inheritedType;
+    for (const entry of node.entries) {
+      if (!isGroupKey(entry.key) || entry.value.kind !== "object") continue;
+      const childPath = [...path, entry.key];
+      if (isTokenNode(entry.value)) {
+        out.push(readToken(entry.value, childPath.join("."), groupType, doc.file));
+      } else {
+        walk2(entry.value, childPath, groupType);
+      }
+    }
+  };
+  walk2(doc.json.root, [], void 0);
+  return out;
+}
 function readToken(node, path, inheritedType, file) {
   const ownType = stringEntry(node, "$type");
   const ext = getEntry(node, "$extensions")?.value;
@@ -548,6 +590,368 @@ function moveToken(doc, from, to) {
   return true;
 }
 
+// ../core/src/token-set.ts
+var isTokenFile = (file) => file.endsWith(".tokens.json");
+var pathId = (path) => `path:${path}`;
+var overrideKey = (brand, theme, path) => `${brand}|${theme}|${path}`;
+function layoutOptions(config) {
+  const first = (list, def) => def ? [def, ...list.filter((m) => m !== def)] : list;
+  return {
+    dirs: config.tokens,
+    order: {
+      brand: first(config.modes.brands, config.modes.defaults.brand),
+      theme: first(config.modes.themes, config.modes.defaults.theme),
+      density: first(config.modes.densities, config.modes.defaults.density)
+    }
+  };
+}
+var FALLBACK_ORDER = { theme: ["light", "dark"], brand: [], density: [] };
+var stem = (file) => file.slice(file.lastIndexOf("/") + 1).replace(/\.tokens\.json$/, "");
+function ordered(list, pref) {
+  const rank2 = (m) => pref.indexOf(m) === -1 ? 99 : pref.indexOf(m);
+  return list.sort((a, b) => rank2(a.mode) - rank2(b.mode) || a.mode.localeCompare(b.mode));
+}
+function detectLayout(files, options = {}) {
+  const d = { ...DEFAULT_TOKEN_PATHS, ...options.dirs };
+  const inDir = (file, dir) => file.startsWith(`${dir}/`) && !file.slice(dir.length + 1).includes("/");
+  const layout = { primitiveFiles: [], brands: [], baseFiles: [], themes: [], overrides: [], densities: [], componentFiles: [] };
+  for (const file of files.filter(isTokenFile).sort()) {
+    const name = stem(file);
+    if (inDir(file, d.brands)) {
+      const parts = name.split(".");
+      if (parts.length === 2) layout.overrides.push({ brand: parts[0], theme: parts[1], file });
+      else layout.brands.push({ mode: name, file });
+    } else if (inDir(file, d.semantic)) {
+      if (name === d.base) layout.baseFiles.push(file);
+      else layout.themes.push({ mode: name, file });
+    } else if (inDir(file, d.density)) layout.densities.push({ mode: name, file });
+    else if (file.startsWith(`${d.components}/`)) layout.componentFiles.push(file);
+    else layout.primitiveFiles.push(file);
+  }
+  ordered(layout.brands, options.order?.brand ?? FALLBACK_ORDER.brand);
+  ordered(layout.themes, options.order?.theme ?? FALLBACK_ORDER.theme);
+  ordered(layout.densities, options.order?.density ?? FALLBACK_ORDER.density);
+  return layout;
+}
+function readScopes(ext) {
+  const s = ext?.[EXT_SCOPES];
+  return Array.isArray(s) && s.every((x) => typeof x === "string") ? s : void 0;
+}
+function readId(ext) {
+  const id = ext?.[EXT_ID];
+  return typeof id === "string" && id ? id : void 0;
+}
+var TIER_LABEL = {
+  primitive: "a primitive",
+  brand: "a brand token",
+  base: "a base semantic token",
+  semantic: "a semantic token",
+  density: "a density token",
+  component: "a component token"
+};
+function buildTokenSet(files, options = {}) {
+  const problems = [];
+  const docs = /* @__PURE__ */ new Map();
+  for (const [file, text] of Object.entries(files)) {
+    if (!isTokenFile(file)) continue;
+    try {
+      docs.set(file, parseTokenFile(file, text));
+    } catch (err) {
+      problems.push(`${file} is not valid JSON: ${err.message}`);
+    }
+  }
+  const layout = detectLayout([...docs.keys()], options);
+  const tokens = /* @__PURE__ */ new Map();
+  const byPath = /* @__PURE__ */ new Map();
+  const add = (t) => {
+    if (tokens.has(t.id)) {
+      problems.push(`Two tokens share the id "${t.id}" (${tokens.get(t.id).path} and ${t.path}).`);
+      return;
+    }
+    tokens.set(t.id, t);
+    byPath.set(t.path, t);
+  };
+  const single = (tier, fileList) => {
+    for (const file of fileList) {
+      for (const flat of flattenTokens(docs.get(file))) {
+        const prev = byPath.get(flat.path);
+        if (prev) {
+          problems.push(
+            prev.tier === tier ? `${flat.path} is defined twice (${prev.files[SINGLE_MODE]} and ${file}).` : `${flat.path} exists both as ${TIER_LABEL[prev.tier]} and as ${TIER_LABEL[tier]} (${file}).`
+          );
+          continue;
+        }
+        if (!flat.type) problems.push(`${flat.path} in ${file} has no $type.`);
+        add({
+          id: readId(flat.extensions) ?? pathId(flat.path),
+          path: flat.path,
+          type: flat.type ?? "unknown",
+          tier,
+          values: { [SINGLE_MODE]: flat.value },
+          description: flat.description,
+          scopes: readScopes(flat.extensions),
+          files: { [SINGLE_MODE]: file }
+        });
+      }
+    }
+  };
+  const multi = (tier, modes) => {
+    const merged = /* @__PURE__ */ new Map();
+    for (const { mode, file } of modes) {
+      for (const flat of flattenTokens(docs.get(file))) {
+        let t = merged.get(flat.path);
+        if (!t) {
+          const prev = byPath.get(flat.path);
+          if (prev) {
+            problems.push(`${flat.path} exists both as ${TIER_LABEL[prev.tier]} and as ${TIER_LABEL[tier]} (${file}).`);
+            continue;
+          }
+          t = {
+            id: readId(flat.extensions) ?? pathId(flat.path),
+            path: flat.path,
+            type: flat.type ?? "unknown",
+            tier,
+            values: {},
+            description: flat.description,
+            scopes: readScopes(flat.extensions),
+            files: {}
+          };
+          merged.set(flat.path, t);
+          if (!flat.type) problems.push(`${flat.path} in ${file} has no $type.`);
+        } else if (flat.type && t.type !== flat.type) {
+          problems.push(`${flat.path} has type ${t.type} in one mode and ${flat.type} in ${file}.`);
+        }
+        t.values[mode] = flat.value;
+        t.files[mode] = file;
+        t.description ??= flat.description;
+        t.scopes ??= readScopes(flat.extensions);
+      }
+    }
+    merged.forEach(add);
+  };
+  single("primitive", layout.primitiveFiles);
+  multi("brand", layout.brands);
+  single("base", layout.baseFiles);
+  multi("semantic", layout.themes);
+  multi("density", layout.densities);
+  single("component", layout.componentFiles);
+  const overrides = [];
+  const overrideIndex = /* @__PURE__ */ new Map();
+  for (const o of layout.overrides) {
+    for (const flat of flattenTokens(docs.get(o.file))) {
+      overrides.push({ brand: o.brand, theme: o.theme, path: flat.path, type: flat.type, value: flat.value, file: o.file });
+      overrideIndex.set(overrideKey(o.brand, o.theme, flat.path), flat.value);
+    }
+  }
+  return { tokens, byPath, docs, layout, options, overrides, overrideIndex, problems };
+}
+
+// ../core/src/token-merge.ts
+var idOf = (f) => {
+  const id = f.extensions?.[EXT_ID];
+  return typeof id === "string" && id ? id : pathId(f.path);
+};
+function logical(f) {
+  const scopes = f.extensions?.[EXT_SCOPES];
+  return {
+    id: idOf(f),
+    path: f.path,
+    type: f.type ?? "unknown",
+    // One file holds one tier: the tier only feeds default scopes, the same on every side.
+    tier: "primitive",
+    values: { [SINGLE_MODE]: f.value },
+    description: f.description,
+    scopes: Array.isArray(scopes) ? scopes.map(String) : void 0,
+    files: { [SINGLE_MODE]: f.file }
+  };
+}
+function readSide(file, text, problems, label) {
+  const side = { doc: void 0, flat: /* @__PURE__ */ new Map(), logical: /* @__PURE__ */ new Map() };
+  if (text === void 0) return side;
+  try {
+    side.doc = parseTokenFile(file, text);
+  } catch (err) {
+    problems.push(`${file} (${label}) is not valid JSON: ${err.message}`);
+    return side;
+  }
+  for (const f of flattenTokens(side.doc)) {
+    const id = idOf(f);
+    side.flat.set(id, f);
+    side.logical.set(id, logical(f));
+  }
+  return side;
+}
+function diffFile(input, file, problems) {
+  const base = readSide(file, input.base[file], problems, "shared start");
+  const mine = readSide(file, input.mine[file], problems, "this change");
+  const theirs = readSide(file, input.theirs[file], problems, "latest library");
+  const r = threeWayDiff(base.logical, mine.logical, theirs.logical);
+  return { file, base, mine, theirs, local: r.local, remote: r.remote, conflicts: r.conflicts };
+}
+function removedSide(c) {
+  if (!c.base) return null;
+  if (!c.mine && c.theirs) return "mine";
+  if (!c.theirs && c.mine) return "theirs";
+  return null;
+}
+var defaultChoiceFor = (c) => removedSide(c) ? null : "mine";
+function planTokenMerge(input) {
+  const problems = [];
+  const files = [...new Set(input.files)].sort();
+  const conflicts = [];
+  let mineOnly = 0;
+  let theirsOnly = 0;
+  for (const file of files) {
+    const d = diffFile(input, file, problems);
+    mineOnly += d.local.length;
+    theirsOnly += d.remote.length;
+    for (const e of d.conflicts) {
+      const c = { base: d.base.flat.get(e.id), mine: d.mine.flat.get(e.id), theirs: d.theirs.flat.get(e.id) };
+      conflicts.push({ key: `${file}#${e.id}`, file, path: (c.mine ?? c.theirs ?? c.base).path, ...c, removedOn: removedSide(c), defaultChoice: defaultChoiceFor(c) });
+    }
+  }
+  return { files, conflicts, mineOnly, theirsOnly, problems };
+}
+var choiceFor = (c, choices) => choices[c.key] ?? c.defaultChoice;
+function missingChoices(plan, choices) {
+  return plan.conflicts.filter((c) => choiceFor(c, choices) === null);
+}
+function takeMine(doc, mine, existing) {
+  if (!mine) return existing ? removeToken(doc, existing.path) : false;
+  let changed = false;
+  if (existing && existing.path !== mine.path) changed = removeToken(doc, existing.path) || changed;
+  const extensions = {};
+  for (const k of Object.keys(existing?.path === mine.path ? existing.extensions ?? {} : {})) extensions[k] = void 0;
+  Object.assign(extensions, mine.extensions ?? {});
+  return upsertToken(doc, mine.path, { type: mine.type, value: mine.value, description: mine.description, extensions }) || changed;
+}
+function applyTokenMerge(input, choices) {
+  const plan = planTokenMerge(input);
+  if (plan.problems.length) throw new Error(plan.problems[0]);
+  const missing = missingChoices(plan, choices);
+  if (missing.length) throw new Error(`Pick a value for ${missing.map((c) => c.path).join(", ")} first.`);
+  const byKey = new Map(plan.conflicts.map((c) => [c.key, c]));
+  const kept = { mine: 0, theirs: 0 };
+  const files = {};
+  for (const file of plan.files) {
+    const d = diffFile(input, file, []);
+    const doc = d.theirs.doc ?? emptyTokenFile(file);
+    for (const e of d.local) takeMine(doc, d.mine.flat.get(e.id), d.theirs.flat.get(e.id) ?? d.base.flat.get(e.id));
+    for (const e of d.conflicts) {
+      const side = choiceFor(byKey.get(`${file}#${e.id}`), choices);
+      kept[side]++;
+      if (side === "mine") takeMine(doc, d.mine.flat.get(e.id), d.theirs.flat.get(e.id));
+    }
+    const empty = flattenTokens(doc).length === 0;
+    files[file] = empty && (input.theirs[file] === void 0 || input.mine[file] === void 0) ? null : serializeTokenFile(doc);
+  }
+  return { files, kept };
+}
+
+// ../core/src/token-combine.ts
+var idOf2 = (f) => {
+  const id = f.extensions?.[EXT_ID];
+  return typeof id === "string" && id ? id : pathId(f.path);
+};
+function tokensOf(file, text, problems, label) {
+  const out = /* @__PURE__ */ new Map();
+  if (text === void 0) return out;
+  try {
+    for (const t of flattenTokens(parseTokenFile(file, text))) out.set(idOf2(t), t);
+  } catch (err) {
+    problems.push(`${file} (${label}) is not valid JSON: ${err.message}`);
+  }
+  return out;
+}
+var shape = (t) => t ? JSON.stringify([t.path, t.type ?? null, t.value, t.description ?? null]) : "removed";
+var look = (t) => t ? JSON.stringify([t.path, t.type ?? null, t.value]) : "removed";
+function changeEdits(src) {
+  const problems = [];
+  const edits = [];
+  for (const file of [...new Set(src.files)].sort()) {
+    const before = tokensOf(file, src.base[file], problems, "start");
+    const after = tokensOf(file, src.head[file], problems, `change ${src.number}`);
+    for (const id of /* @__PURE__ */ new Set([...before.keys(), ...after.keys()])) {
+      const a = before.get(id);
+      const b = after.get(id);
+      if (shape(a) === shape(b)) continue;
+      edits.push({ key: `${file}#${id}`, file, path: (b ?? a).path, change: src.number, token: b });
+    }
+  }
+  return { number: src.number, edits, problems };
+}
+function byToken(changes) {
+  const out = /* @__PURE__ */ new Map();
+  for (const c of changes) for (const e of c.edits) out.set(e.key, [...out.get(e.key) ?? [], e]);
+  return out;
+}
+function optionsOf(edits) {
+  const out = [];
+  for (const e of edits) {
+    const l = look(e.token);
+    const hit = out.find((o) => o.look === l);
+    if (hit) hit.option.changes.push(e.change);
+    else out.push({ look: l, option: { changes: [e.change], token: e.token } });
+  }
+  return out.map((o) => o.option);
+}
+function pickedOption(c, picks) {
+  const n = picks[c.key];
+  return n === void 0 ? null : c.options.find((o) => o.changes.includes(n)) ?? null;
+}
+function combineChanges(latest, changes, picks = {}, opts = {}) {
+  const on = opts.include ? changes.filter((c) => opts.include.includes(c.number)) : changes;
+  const problems = on.flatMap((c) => c.problems);
+  const groups = byToken(on);
+  const conflicts = [];
+  const missing = [];
+  const from = {};
+  const docs = /* @__PURE__ */ new Map();
+  const docOf = (file) => {
+    if (docs.has(file)) return docs.get(file);
+    const text = latest[file];
+    let doc;
+    try {
+      doc = text === void 0 ? emptyTokenFile(file) : parseTokenFile(file, text);
+    } catch (err) {
+      problems.push(`${file} (latest library) is not valid JSON: ${err.message}`);
+      return null;
+    }
+    docs.set(file, doc);
+    return doc;
+  };
+  for (const [key, edits] of groups) {
+    const options = optionsOf(edits);
+    let use = options[0];
+    if (options.length > 1) {
+      const conflict = { key, file: edits[0].file, path: edits[0].path, options };
+      conflicts.push(conflict);
+      use = pickedOption(conflict, picks);
+      if (!use) {
+        missing.push(conflict);
+        use = opts.unpicked === "first" ? options[0] : null;
+      }
+    }
+    if (!use) continue;
+    const doc = docOf(edits[0].file);
+    if (!doc) continue;
+    const existing = flattenTokens(doc).find((t) => idOf2(t) === key.slice(key.indexOf("#") + 1));
+    takeMine(doc, use.token, existing);
+    const path = use.token?.path ?? edits[0].path;
+    from[path] = [.../* @__PURE__ */ new Set([...from[path] ?? [], ...use.changes])];
+  }
+  const files = { ...latest };
+  for (const [file, doc] of docs) {
+    if (latest[file] === void 0 && flattenTokens(doc).length === 0) continue;
+    files[file] = serializeTokenFile(doc);
+  }
+  const tokens = new Set([...groups.values()].map((e) => e[0].path)).size;
+  return { files, included: on.map((c) => c.number), edits: groups.size, tokens, conflicts, missing, from, problems };
+}
+function encodePicks(picks) {
+  return Object.entries(picks).filter(([, n]) => Number.isSafeInteger(n) && n > 0).sort(([a], [b]) => a.localeCompare(b)).map(([key, n]) => `${n}:${key}`).join("~");
+}
+
 // ../core/src/pr-composer.ts
 var RISK_TIER = RISK_LABELS[3];
 function slugify(text, max = 40) {
@@ -711,6 +1115,84 @@ function applyTokenEdits(base, edits) {
   return { files, touched: [...touched].filter((f) => files.get(f) !== base.files.get(f)).sort(), notes };
 }
 
+// ../core/src/protection.ts
+var PROTECTION_PARTS = ["review", "checks", "history", "deletion"];
+var protectionRulesetName = (defaultBranch) => `Protect the library (${defaultBranch})`;
+function refPattern(pattern) {
+  const src = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\u0000/g, ".*");
+  return new RegExp(`^${src}$`);
+}
+function rulesetTargetsDefault(ruleset, defaultBranch) {
+  if (ruleset.target && ruleset.target !== "branch") return false;
+  const ref = `refs/heads/${defaultBranch}`;
+  const hit = (p) => p === "~ALL" || p === "~DEFAULT_BRANCH" || p === ref || p === defaultBranch || refPattern(p.startsWith("refs/") ? p : `refs/heads/${p}`).test(ref);
+  const cond = ruleset.conditions?.ref_name;
+  if (!cond) return false;
+  if ((cond.exclude ?? []).some(hit)) return false;
+  return (cond.include ?? []).some(hit);
+}
+var count = (v) => typeof v === "number" ? v : 0;
+function rulesetParts(ruleset) {
+  const parts = /* @__PURE__ */ new Set();
+  if (ruleset.enforcement !== "active") return parts;
+  for (const rule of ruleset.rules ?? []) {
+    if (rule.type === "deletion") parts.add("deletion");
+    if (rule.type === "non_fast_forward") parts.add("history");
+    if (rule.type === "pull_request" && count(rule.parameters?.required_approving_review_count) >= 1) parts.add("review");
+    if (rule.type === "required_status_checks" && Array.isArray(rule.parameters?.required_status_checks) && rule.parameters.required_status_checks.length > 0) parts.add("checks");
+  }
+  return parts;
+}
+function classicParts(p) {
+  const parts = /* @__PURE__ */ new Set();
+  if (count(p.required_pull_request_reviews?.required_approving_review_count) >= 1) parts.add("review");
+  if (((p.required_status_checks?.contexts?.length ?? 0) || (p.required_status_checks?.checks?.length ?? 0)) > 0) parts.add("checks");
+  if (!p.allow_force_pushes?.enabled) parts.add("history");
+  if (!p.allow_deletions?.enabled) parts.add("deletion");
+  return parts;
+}
+var rulesetUrl = (r) => r.html_url ?? r._links?.html?.href;
+function protectionState(rulesets, branchProtection, defaultBranch) {
+  const bridge = rulesets?.find((r) => r.name === protectionRulesetName(defaultBranch));
+  const extra = bridge?.id !== void 0 ? { bridgeRulesetId: bridge.id } : {};
+  const covered = /* @__PURE__ */ new Set();
+  let url;
+  for (const r of rulesets ?? []) {
+    if (!rulesetTargetsDefault(r, defaultBranch)) continue;
+    const parts = rulesetParts(r);
+    if (parts.size && !url) url = rulesetUrl(r);
+    parts.forEach((p) => covered.add(p));
+  }
+  if (branchProtection) classicParts(branchProtection).forEach((p) => covered.add(p));
+  const missing = PROTECTION_PARTS.filter((p) => !covered.has(p));
+  const withUrl = url ? { url } : {};
+  if (!missing.length) return { kind: "protected", missing, ...extra, ...withUrl };
+  const unreadable = rulesets == null || branchProtection === void 0;
+  if (covered.size === 0) return { kind: unreadable ? "unknown" : "unprotected", missing, ...extra };
+  return { kind: "partial", missing, ...extra, ...withUrl };
+}
+var PROTECTION_PART_PHRASE = {
+  review: "changes can skip review",
+  checks: "checks do not have to pass",
+  history: "past changes can be rewritten",
+  deletion: "the library can be deleted"
+};
+var joinAnd = (xs) => xs.length <= 1 ? xs[0] ?? "" : `${xs.slice(0, -1).join(", ")} and ${xs[xs.length - 1]}`;
+function protectionSentence(state) {
+  switch (state.kind) {
+    case "protected":
+      return "Protected: every change goes through review.";
+    case "unprotected":
+      return "Your library can be changed without review.";
+    case "partial": {
+      const s = joinAnd(state.missing.map((p) => PROTECTION_PART_PHRASE[p]));
+      return `Partly protected: ${s}.`;
+    }
+    default:
+      return "Protection status unknown: GitHub did not let this token read it.";
+  }
+}
+
 // ../core/src/github-client.ts
 var GitHubError = class extends Error {
   constructor(status, message, detail, info = {}) {
@@ -1333,7 +1815,7 @@ var GitHubClient = class _GitHubClient {
   }
   async getPullRequest(n) {
     const r = await this.request("GET", `${this.repoPath}/pulls/${n}`);
-    return { ...toSummary(r), body: r.body ?? "", mergeable: r.mergeable ?? null };
+    return { ...toSummary(r), body: r.body ?? "", mergeable: r.mergeable ?? null, requestedReviewers: (r.requested_reviewers ?? []).map((x) => x.login) };
   }
   async listPullRequestFiles(n) {
     const r = await this.request("GET", `${this.repoPath}/pulls/${n}/files?per_page=100`);
@@ -1410,6 +1892,100 @@ var GitHubClient = class _GitHubClient {
   async removeLabel(issueNumber, label) {
     await this.request("DELETE", `${this.repoPath}/issues/${issueNumber}/labels/${encodeURIComponent(label)}`);
   }
+  // --- branch actions shared by Studio, the MCP server and the CLI (branch-actions.ts) ---
+  /** The account the token belongs to (GET /user). Needs a token. */
+  async getViewer() {
+    this.assertToken("Reading who you are on GitHub");
+    const r = await this.request("GET", "/user");
+    return { login: r.login };
+  }
+  /** The repository's merge settings and the viewer's permissions (unknown settings count as allowed). */
+  async getMergeSettings() {
+    return this.request("GET", this.repoPath);
+  }
+  /**
+   * Merges a pull request, only at `sha` (GitHub refuses when the branch moved meanwhile). The repository's branch
+   * rules still apply: GitHub refuses a merge they block, whatever Bridge says.
+   */
+  async mergePullRequest(n, input) {
+    this.assertToken("Merging a branch");
+    const r = await this.request("PUT", `${this.repoPath}/pulls/${n}/merge`, {
+      merge_method: input.method,
+      sha: input.sha,
+      ...input.commitMessage !== void 0 && input.method !== "rebase" ? { commit_message: input.commitMessage } : {}
+    });
+    return { sha: r?.sha ?? "", merged: r?.merged ?? true };
+  }
+  /** GitHub's "Update branch": merges the base into the pull request, only when its head is still `expectedHeadSha`. */
+  async updatePullRequestBranch(n, expectedHeadSha) {
+    this.assertToken("Updating a branch from main");
+    await this.request("PUT", `${this.repoPath}/pulls/${n}/update-branch`, { expected_head_sha: expectedHeadSha });
+  }
+  /** Posts a comment on an issue or pull request and returns its id and link. */
+  async createIssueComment(n, body) {
+    this.assertToken("Commenting");
+    const r = await this.request("POST", `${this.repoPath}/issues/${n}/comments`, { body });
+    return { id: r.id, url: r.html_url };
+  }
+  /** Replaces the text of a comment. */
+  async updateIssueComment(id, body) {
+    this.assertToken("Editing a comment");
+    await this.request("PATCH", `${this.repoPath}/issues/comments/${id}`, { body });
+  }
+  /** Submits a review on a given commit (the head the reviewer saw); the body may be empty for an approval. */
+  async submitReview(n, input) {
+    this.assertToken("Reviewing a branch");
+    const r = await this.request("POST", `${this.repoPath}/pulls/${n}/reviews`, {
+      event: input.event,
+      ...input.body ? { body: input.body } : {},
+      ...input.commitId ? { commit_id: input.commitId } : {}
+    });
+    return { id: r.id, user: r.user?.login, state: r.state, body: r.body ?? "" };
+  }
+  /** Line comments of a pull request (review threads), oldest first. */
+  async listReviewComments(n) {
+    const r = await this.request(
+      "GET",
+      `${this.repoPath}/pulls/${n}/comments?per_page=100`
+    );
+    return r.map((c) => ({ id: c.id, body: c.body ?? "", author: c.user?.login ?? "unknown", path: c.path, line: c.line ?? null, inReplyTo: c.in_reply_to_id ?? null, url: c.html_url, createdAt: c.created_at }));
+  }
+  /** Asks these people to review a pull request. */
+  async requestReviewers(n, logins) {
+    this.assertToken("Asking for a review");
+    await this.request("POST", `${this.repoPath}/pulls/${n}/requested_reviewers`, { reviewers: logins });
+  }
+  /** Takes these people off the requested reviewers. */
+  async removeRequestedReviewers(n, logins) {
+    this.assertToken("Changing the requested reviewers");
+    await this.request("DELETE", `${this.repoPath}/pulls/${n}/requested_reviewers`, { reviewers: logins });
+  }
+  /** Replies in the thread of a line comment. */
+  async replyToReviewComment(n, commentId, body) {
+    this.assertToken("Replying to a comment");
+    const r = await this.request("POST", `${this.repoPath}/pulls/${n}/comments/${commentId}/replies`, { body });
+    return { id: r.id, url: r.html_url };
+  }
+  /**
+   * What `head` adds on top of `base`, with what library sync needs: the shared start (merge base), the base
+   * commit and its tree, how far behind, and the files with their previous names.
+   */
+  async compareDetailed(base, head) {
+    const r = await this.request("GET", `${this.repoPath}/compare/${encodeRef(base)}...${encodeRef(head)}`);
+    return {
+      behindBy: r.behind_by,
+      aheadBy: r.ahead_by,
+      mergeBase: r.merge_base_commit?.sha ?? null,
+      baseSha: r.base_commit?.sha ?? null,
+      baseTree: r.base_commit?.commit?.tree?.sha ?? null,
+      files: (r.files ?? []).map((f) => ({ filename: f.filename, status: f.status, ...f.previous_filename ? { previous_filename: f.previous_filename } : {} }))
+    };
+  }
+  /** A tree on top of `baseTree` from entries with their own file mode (blob sha, inline content, or sha null to delete). */
+  async createTreeEntries(baseTree, entries) {
+    const r = await this.request("POST", `${this.repoPath}/git/trees`, { base_tree: baseTree, tree: entries.map((e) => ({ ...e, type: "blob" })) }, true);
+    return r.sha;
+  }
 };
 function toCommitSummary(c) {
   return {
@@ -1477,6 +2053,13 @@ function toIssue(r) {
   };
 }
 
+// ../core/src/protection-github.ts
+async function loadProtection(client2, defaultBranch) {
+  const rulesets = await client2.listRulesets().then((list) => Promise.all(list.map((r) => r.enforcement === "disabled" || r.id === void 0 ? r : client2.getRuleset(r.id)))).catch(() => null);
+  const classic = await client2.getBranchProtection(defaultBranch).catch(() => void 0);
+  return protectionState(rulesets, classic, defaultBranch);
+}
+
 // ../core/src/history.ts
 var BULK_LIMIT = 60;
 var UNRELEASED = "Unreleased";
@@ -1668,11 +2251,11 @@ function modeLabel(modes) {
   return s.charAt(0).toUpperCase() + s.slice(1);
 }
 function tokenHistory(entries, path, config) {
-  const names = /* @__PURE__ */ new Set([path]);
+  const names2 = /* @__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) => names.has(c.path));
+    const hits = e.changes.filter((c) => names2.has(c.path));
     for (const c of hits) {
       const modes = config ? fileModes(config, c.file) : {};
       out.push({
@@ -1700,7 +2283,7 @@ function tokenHistory(entries, path, config) {
         ...c.descriptionAfter !== void 0 ? { descriptionAfter: c.descriptionAfter } : {}
       });
     }
-    for (const c of hits) if (c.kind === "renamed" && c.from) names.add(c.from);
+    for (const c of hits) if (c.kind === "renamed" && c.from) names2.add(c.from);
   }
   return out;
 }
@@ -2732,7 +3315,7 @@ ${text.trim()}
     ] : [],
     ...options.rewrite ? ["Rewrite each one from the facts and the source: keep what is true in the current text, drop what the code does not support."] : []
   ] : [`Write the missing prose of ${prefill.component}.docs.json for the Bridge design system.`];
-  const shape = keys ? [
+  const shape2 = keys ? [
     `- ${check.length ? "Return" : "Write"} only these keys: ${keys.join(", ")}${check.length ? ` (the checked ones, ${check.join(", ")}, only when they need a fix)` : ""}. Never return anatomy, preview or any other key: code decides them.`,
     `- Answer with one JSON object holding only those keys, nothing else: ${docsSectionShapes(keys)}.`
   ] : [
@@ -2746,7 +3329,7 @@ ${text.trim()}
     "- Ground every sentence in the facts and the source below. Never invent props, variants, keyboard behavior or tokens that are not there.",
     "- Bridge voice: sentence case, plain words, verbs first, no em dashes, no marketing words.",
     '- Keep the keys and shapes of the example docs.json. dos and donts are { "title", "text" } objects; add an "example" only with components and props that exist.',
-    ...shape,
+    ...shape2,
     "",
     "Facts computed from the code:",
     facts.join("\n\n"),
@@ -2778,6 +3361,30 @@ function formatDocsJson(d) {
   return `${JSON.stringify(out, null, 2)}
 `;
 }
+function patchNode(old, next) {
+  if (plainEqual(toPlain(old), next)) return old;
+  if (old.kind === "object" && next && typeof next === "object" && !Array.isArray(next)) {
+    const n = next;
+    const kept = old.entries.filter((e) => n[e.key] !== void 0).map((e) => ({ key: e.key, value: patchNode(e.value, n[e.key]) }));
+    const added = Object.keys(n).filter((k) => n[k] !== void 0 && !getEntry(old, k)).map((k) => ({ key: k, value: fromPlain(n[k], void 0, old.inline) }));
+    return { kind: "object", inline: old.inline, entries: [...kept, ...added] };
+  }
+  if (old.kind === "array" && Array.isArray(next)) {
+    return { kind: "array", inline: old.inline, items: next.map((v, i) => old.items[i] ? patchNode(old.items[i], v) : fromPlain(v, old.items[0], old.inline)) };
+  }
+  return fromPlain(next, old);
+}
+function patchDocsJson(original, next) {
+  const plain = JSON.parse(formatDocsJson(next));
+  if (!original) return formatDocsJson(next);
+  try {
+    const doc = parseJson(original);
+    if (doc.root.kind !== "object") return formatDocsJson(next);
+    return serializeJson({ ...doc, root: patchNode(doc.root, plain) });
+  } catch {
+    return formatDocsJson(next);
+  }
+}
 
 // ../core/src/change-drafts.ts
 function cleanDraftText(text) {
@@ -3046,8 +3653,11 @@ function explorationStatus(p) {
   if (p.state === "open" && labelNames(p.labels).includes(EXPLORATION_LABEL)) return "active";
   return "promoted";
 }
+var isActiveExploration = (labels) => labelNames(labels).includes(EXPLORATION_LABEL);
 function promotionPlan(input) {
   const exploration = parseExplorationBody(input.body);
+  const jira = /^([A-Z][A-Z0-9_]*-\d+)\s+/.exec(input.title)?.[1] ?? null;
+  const title = jira ? input.title.slice(jira.length).trim() : input.title;
   const removeFiles = input.files.filter((f) => f.path.startsWith(`${EXPLORATION_NOTES_DIR}/`) && f.status !== "removed").map((f) => f.path);
   const files = input.files.filter((f) => !f.path.startsWith(`${EXPLORATION_NOTES_DIR}/`));
   const risk = classifyRisk({ files, ...input.config ? { config: input.config } : {} });
@@ -3060,13 +3670,13 @@ function promotionPlan(input) {
   const body = [
     `**Promoted from an exploration on ${date}.** Review it like any change: the tier below comes from the files it touches.`,
     "",
-    kept || `## ${input.title.replace(/^Exploration:\s*/i, "")}`,
+    kept || `## ${title.replace(/^Exploration:\s*/i, "")}`,
     "",
     `**Risk tier:** ${risk.tier}.`,
     ...risk.reasons.slice(0, 8).map((r) => `- ${r}`),
     ...closes.length ? ["", ...closes.map((n) => `Closes #${n}`)] : []
   ].join("\n");
-  const t = input.title.replace(/^Exploration:\s*/i, "").trim() || exploration?.name || input.title;
+  const t = title.replace(/^Exploration:\s*/i, "").trim() || exploration?.name || title;
   return {
     tier: risk.tier,
     reasons: risk.reasons,
@@ -3074,7 +3684,7 @@ function promotionPlan(input) {
     addLabels,
     removeFiles,
     body,
-    title: t.charAt(0).toUpperCase() + t.slice(1),
+    title: `${jira ? `${jira} ` : ""}${t.charAt(0).toUpperCase()}${t.slice(1)}`,
     markReady: true
   };
 }
@@ -3435,7 +4045,7 @@ function explorationSummary(p, _owner, _repo, s) {
     url: p.url,
     branch: p.headRef,
     slug: slug2,
-    name: e?.name ?? p.title.replace(/^Exploration:\s*/i, ""),
+    name: e?.name ?? p.title.replace(/^[A-Z][A-Z0-9_]*-\d+\s+/, "").replace(/^Exploration:\s*/i, ""),
     purpose: e?.purpose ?? "",
     ...e?.useCase ? { useCase: e.useCase } : {},
     status: explorationStatus({ state: p.state, labels: p.labels, headRef: p.headRef, body: p.body }),
@@ -3472,7 +4082,8 @@ Exploration: never merged as is. Promote it to review or close it.`,
     files: [{ path: explorationNotePath(slug2), content: explorationNote(full) }]
   });
   const ctx = { owner: gh.owner, repo: gh.name, packages: s.packages, apps: s.apps, ...s.requests?.length ? { requests: s.requests } : {} };
-  const pr = await x.createPullRequest({ title: explorationPrTitle(full), head: branch, base: s.base, body: explorationPrBody(full, ctx), draft: true });
+  const title = full.jira ? `${full.jira.trim().toUpperCase()} ${explorationPrTitle(full)}` : explorationPrTitle(full);
+  const pr = await x.createPullRequest({ title, head: branch, base: s.base, body: explorationPrBody(full, ctx), draft: true });
   await x.addLabels(pr.number, [EXPLORATION_LABEL]);
   await x.updatePullRequest(pr.number, { body: explorationPrBody(full, { ...ctx, pr: pr.number }) }).catch(() => void 0);
   return {
@@ -3535,6 +4146,699 @@ async function closeExplorationOnGitHub(gh, ref) {
   return { number: p.number, url: p.url, branch: p.headRef };
 }
 
+// ../core/src/review-gate.ts
+function parseTier(labels, body) {
+  const found = [];
+  for (const l of labels) {
+    const m = l.name.match(/^(?:risk[\s:-]*)?tier[\s:_-]*([123])\b/i) ?? l.name.match(/^risk[\s:_-]*([123])$/i);
+    if (m) found.push(Number(m[1]));
+  }
+  for (const m of (body ?? "").matchAll(/-\s*\[[xX]\]\s*\**\s*Tier\s*([123])\b/g)) found.push(Number(m[1]));
+  for (const m of (body ?? "").matchAll(/risk tier\W{0,6}(?:tier\s*)?([123])\b/gi)) found.push(Number(m[1]));
+  return found.length ? Math.max(...found) : null;
+}
+function pullState(p) {
+  if (p.merged_at || p.merged) return "merged";
+  if (p.state && p.state !== "open") return "closed";
+  if (p.draft) return "draft";
+  return "open";
+}
+function openPulls(pulls) {
+  return pulls.filter((p) => {
+    const s = pullState(p);
+    return s === "open" || s === "draft";
+  });
+}
+var OK = /* @__PURE__ */ new Set(["success", "neutral", "skipped"]);
+function summarizeCi(runs, statuses = []) {
+  const failed = [];
+  const pending = [];
+  let passed = 0;
+  for (const r of runs) {
+    if (r.status !== "completed") pending.push({ name: r.name, url: r.html_url });
+    else if (r.conclusion && OK.has(r.conclusion)) passed++;
+    else failed.push({ name: r.name, url: r.html_url });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const s of statuses) {
+    if (seen.has(s.context)) continue;
+    seen.add(s.context);
+    if (s.state === "success") passed++;
+    else if (s.state === "pending") pending.push({ name: s.context, url: s.target_url ?? void 0 });
+    else failed.push({ name: s.context, url: s.target_url ?? void 0 });
+  }
+  const total = passed + failed.length + pending.length;
+  const state = total === 0 ? "none" : failed.length ? "fail" : pending.length ? "pending" : "pass";
+  return { state, total, passed, failed, pending };
+}
+function summarizeApprovals(reviews, owners, author) {
+  const latest = /* @__PURE__ */ new Map();
+  const sorted = [...reviews].sort((a2, b) => String(a2.submitted_at ?? "").localeCompare(String(b.submitted_at ?? "")));
+  for (const r of sorted) {
+    const login = r.user?.login;
+    if (!login || login === author) continue;
+    if (r.state === "APPROVED" || r.state === "CHANGES_REQUESTED" || r.state === "DISMISSED") latest.set(login, r.state);
+  }
+  const approvers = [...latest].filter(([, s]) => s === "APPROVED").map(([l]) => l);
+  const changesRequested = [...latest].filter(([, s]) => s === "CHANGES_REQUESTED").map(([l]) => l);
+  const lower = (xs) => xs.map((x) => x.toLowerCase().replace(/^@/, ""));
+  const d = lower(owners.design);
+  const t = lower(owners.tech);
+  const a = lower(approvers);
+  let design;
+  let tech;
+  if (d.length || t.length) {
+    design = d.length ? a.some((x) => d.includes(x)) : a.length > 0;
+    const soloBoth = (x) => a.length === 1 && d.includes(x);
+    tech = t.length ? a.some((x) => t.includes(x) && !soloBoth(x)) : a.length > 1;
+  } else {
+    design = a.length >= 1;
+    tech = a.length >= 2;
+  }
+  return { approvers, changesRequested, design, tech };
+}
+var normLogin = (x) => x.trim().toLowerCase().replace(/^@/, "");
+function canOverride(login, policy) {
+  if (!login || !policy?.allowed.length) return false;
+  return policy.allowed.map(normLogin).includes(normLogin(login));
+}
+function mergeGate(input) {
+  const blocking = [];
+  const missing = [];
+  const approvalReasons = [];
+  const lifecycle = pullState(input);
+  if (lifecycle === "merged") blocking.push("This branch is already merged.");
+  else if (lifecycle === "closed") blocking.push("This branch is closed.");
+  if (input.exploration && lifecycle !== "merged" && lifecycle !== "closed") blocking.push("It is an exploration: promote it to review first.");
+  if (input.draft) blocking.push("It is a draft. Mark it ready for review on GitHub first.");
+  if (input.ci.state === "fail") blocking.push(`Tests fail: ${input.ci.failed.map((f) => f.name).join(", ")}.`);
+  if (input.ci.state === "pending") blocking.push("Tests are still running.");
+  if (input.approvals.changesRequested.length) blocking.push(`Changes requested by @${input.approvals.changesRequested.join(", @")}.`);
+  const tier = input.tier ?? 3;
+  if (tier >= 2) {
+    if (!input.approvals.design) {
+      approvalReasons.push("It needs a design owner approval.");
+      missing.push("design approval");
+    }
+    if (!input.approvals.tech) {
+      approvalReasons.push("It needs a tech owner approval.");
+      missing.push("tech approval");
+    }
+  } else if (!input.approvals.approvers.length) {
+    approvalReasons.push("It needs one approval.");
+    missing.push("approval");
+  }
+  const conflict = input.mergeable === false ? [CONFLICT_REASON] : [];
+  const shipper = !input.viewer || canShip(input.viewer, input.ship);
+  const ship = !shipper && lifecycle !== "merged" && lifecycle !== "closed" ? [whoCanShipSentence(input.ship), ...unreadableShipTeams(input.ship).map((t) => t.status === "unreadable" ? t.message : "")] : [];
+  const reasons = [...blocking, ...approvalReasons, ...ship, ...conflict];
+  const allowed = reasons.length === 0;
+  const overridable = !allowed && blocking.length + conflict.length + ship.length === 0 && missing.length > 0 && canOverride(input.viewer, input.override);
+  return { allowed, reasons, overridable, missing, canShip: shipper };
+}
+var CONFLICT_REASON = "It conflicts with main: resolve it with Update from main on the branch.";
+var OVERRIDE_HEADING = "**Bridge owner override**";
+function overrideReasonProblem(reason, policy) {
+  if (!policy.requireReason) return null;
+  const n = reason.trim().length;
+  if (n === 0) return `Write why this merges without the missing approvals, in at least ${policy.minReasonLength} characters.`;
+  if (n < policy.minReasonLength) return `Write at least ${policy.minReasonLength} characters (${n} so far), so the history says why.`;
+  return null;
+}
+function overrideComment(login, reason, missing) {
+  const why = reason.trim().replace(/\s+/g, " ").replace(/[.\s]+$/, "");
+  return `${OVERRIDE_HEADING}
+
+Owner override by @${normLogin(login)}: ${why || "no reason given"}. Missing: ${missing.join(", ")}. Merged from Bridge.`;
+}
+function overrideRefusedComment(body, message) {
+  return body.replace(/ Merged from Bridge\.$/, ` Merge refused by GitHub: ${message.trim().replace(/[.\s]+$/, "")}. Not merged.`);
+}
+function allowedMergeMethods(repo) {
+  const out = [];
+  if (repo?.allow_squash_merge !== false) out.push("squash");
+  if (repo?.allow_merge_commit !== false) out.push("merge");
+  if (repo?.allow_rebase_merge !== false) out.push("rebase");
+  return out;
+}
+function hasWriteAccess(perms) {
+  return Boolean(perms && (perms.admin || perms.maintain || perms.push));
+}
+var REVIEW_STATUS_ORDER = {
+  "ci-failing": 0,
+  conflict: 1,
+  "changes-requested": 2,
+  "needs-design": 3,
+  "needs-tech": 4,
+  "needs-approval": 5,
+  ready: 6,
+  "ci-running": 7,
+  checking: 8,
+  unknown: 9,
+  draft: 10,
+  merged: 11,
+  closed: 12
+};
+function reviewStatusKind(input) {
+  const out = (kind) => kind;
+  const lifecycle = pullState(input);
+  if (lifecycle === "merged") return out("merged");
+  if (lifecycle === "closed") return out("closed");
+  if (lifecycle === "draft") return out("draft");
+  if (input.ci?.state === "fail") return out("ci-failing");
+  if (input.approvals?.changesRequested.length) return out("changes-requested");
+  if (input.mergeable === false) return out("conflict");
+  if (input.ci?.state === "pending") return out("ci-running");
+  if (!input.ci || !input.approvals) return out("unknown");
+  if (input.mergeable === null) return out("checking");
+  const tier = input.tier ?? 3;
+  if (tier >= 2) {
+    if (!input.approvals.design) return out("needs-design");
+    if (!input.approvals.tech) return out("needs-tech");
+  } else if (!input.approvals.approvers.length) return out("needs-approval");
+  const gate = mergeGate({ tier: input.tier, ci: input.ci, approvals: input.approvals, draft: Boolean(input.draft), mergeable: input.mergeable, state: input.state ?? "open", merged_at: input.merged_at });
+  return gate.allowed ? out("ready") : out("unknown");
+}
+var BOTS = /* @__PURE__ */ new Set(["github-actions[bot]", "app/github-actions", "changeset-bot[bot]"]);
+var isReleasePull = (p) => p.head.ref.startsWith("changeset-release/");
+function isAutomationPull(p) {
+  return isReleasePull(p) || BOTS.has((p.user?.login ?? "").toLowerCase());
+}
+var runningExploration = (p) => p.state === "open" && isActiveExploration(p.labels ?? []);
+function reviewQueue(pulls) {
+  return openPulls(pulls).filter((p) => !isAutomationPull(p) && !runningExploration(p));
+}
+function effectiveTier(labels, body, files) {
+  const labelled = parseTier(labels, body);
+  if (!files) return labelled;
+  const computed = classifyRisk({ files: files.map((f) => ({ path: f.filename, status: f.status })) }).tier;
+  return Math.max(labelled ?? 0, computed);
+}
+var norm = (x) => x.trim().toLowerCase().replace(/^@/, "");
+function reopenEligibility(x) {
+  if (x.state !== "closed" || !x.viewer) return { kind: "none" };
+  const isAuthor = norm(x.viewer) === norm(x.author);
+  const isOwner = x.owners.some((o) => norm(o) === norm(x.viewer));
+  if (!isAuthor && !isOwner) return { kind: "none" };
+  if (!x.canWrite && !isAuthor) return { kind: "none" };
+  if (x.branch === "exists") return { kind: "reopen" };
+  if (x.branch === "gone") return { kind: "gone" };
+  return { kind: "none" };
+}
+var NO_CI = { state: "pass", total: 0, passed: 0, failed: [], pending: [] };
+var ROLE_OF_MISSING = { "design approval": "design", "tech approval": "tech", approval: "approval" };
+function pendingApprovals(tier, approvals) {
+  if (tier == null || !approvals) return [];
+  return mergeGate({ tier, ci: NO_CI, approvals, draft: false, state: "open" }).missing.map((m) => ROLE_OF_MISSING[m]);
+}
+var uniqLogins = (xs) => xs.filter((x, i) => xs.findIndex((y) => normLogin(y) === normLogin(x)) === i);
+function eligibleReviewers(role, p) {
+  const raw = role === "design" ? p.owners.design : role === "tech" ? p.owners.tech : uniqLogins([...p.owners.design, ...p.owners.tech]);
+  const listed = raw.map((x) => x.replace(/^@/, ""));
+  const approvers = (p.approvers ?? []).map(normLogin);
+  const logins = listed.filter((l) => normLogin(l) !== normLogin(p.author) && !approvers.includes(normLogin(l)));
+  return { open: listed.length === 0, logins, listed };
+}
+function reviewersToAsk(x) {
+  const roles = pendingApprovals(x.tier, x.approvals);
+  const all = roles.flatMap((r) => eligibleReviewers(r, { owners: x.owners, author: x.author, approvers: x.approvals.approvers }).logins);
+  return uniqLogins(all).filter((l) => normLogin(l) !== normLogin(x.viewer ?? "") && normLogin(l) !== normLogin(x.author));
+}
+
+// ../core/src/library-update.ts
+var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+var names = (files) => files.flatMap((f) => f.previous_filename ? [f.filename, f.previous_filename] : [f.filename]);
+function overlap(changeFiles, libraryFiles, isTokenFile2) {
+  const lib = new Set(names(libraryFiles));
+  const both = [...new Set(names(changeFiles).filter((f) => lib.has(f)))].sort();
+  return { tokenFiles: both.filter(isTokenFile2), codeFiles: both.filter((f) => !isTokenFile2(f)) };
+}
+var COMPARE_FILE_LIMIT = 300;
+function conflictRoute(o, opts = {}) {
+  if (opts.truncated || !o.tokenFiles.length && !o.codeFiles.length) return { kind: "code", alsoTokens: false, files: [] };
+  if (o.codeFiles.length) return { kind: "code", alsoTokens: o.tokenFiles.length > 0, files: o.codeFiles };
+  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 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 ? `
+
+${lines.join("\n")}` : ""}${by}`;
+}
+function freshness(input) {
+  const behindBy = typeof input.compare?.behind_by === "number" ? input.compare.behind_by : null;
+  const mergeBase = input.compare?.merge_base_commit?.sha ?? null;
+  if (!input.open) return { state: "current", behindBy, mergeBase };
+  if (input.mergeable === false) return { state: "conflict", behindBy, mergeBase };
+  if (behindBy === null) return { state: "unknown", behindBy, mergeBase };
+  return { state: behindBy > 0 ? "behind" : "current", behindBy, mergeBase };
+}
+var withoutRoot = (root, p) => root && p.startsWith(`${root}/`) ? p.slice(root.length + 1) : p;
+async function treeAt(gh, sha) {
+  const t = await gh.getTree(await gh.getCommitTree(sha));
+  if (t.truncated) throw new Error("This repository is too big for Bridge to read in one go. A developer resolves the conflict on GitHub.");
+  return new Map(t.entries.filter((e) => e.type === "blob").map((e) => [e.path, e]));
+}
+async function textAt(gh, sha, path) {
+  return await gh.readFile(path, sha) ?? "";
+}
+async function tokenFilesAt(gh, sha, root, tree) {
+  const prefix = root ? `${root}/` : "";
+  const paths = [...tree.keys()].filter((p) => p.startsWith(prefix) && p.endsWith(".tokens.json"));
+  return Object.fromEntries(await Promise.all(paths.map(async (p) => [withoutRoot(root, p), await textAt(gh, sha, p)])));
+}
+async function configAt(gh, sha, tree) {
+  if (!tree.has("bridge.config.json")) return null;
+  try {
+    return loadConfig(await textAt(gh, sha, "bridge.config.json"));
+  } catch {
+    return null;
+  }
+}
+async function readLibraryConflicts(gh, compare, headSha, opts = {}) {
+  const { mergeBase, baseSha: mainSha, baseTree: mainTree } = compare;
+  const changeFiles = compare.files;
+  if (!mergeBase || !mainSha || !mainTree) return { route: conflictRoute({ tokenFiles: [], codeFiles: [] }) };
+  const library = (await gh.compareDetailed(mergeBase, mainSha)).files;
+  const truncated = changeFiles.length >= COMPARE_FILE_LIMIT || library.length >= COMPARE_FILE_LIMIT;
+  const guess = opts.tokensRoot ?? DEFAULT_TOKEN_PATHS.root;
+  const route = conflictRoute(
+    overlap(changeFiles, library, (p) => p.endsWith(".tokens.json") && p.startsWith(`${guess}/`)),
+    { truncated }
+  );
+  if (route.kind !== "tokens") return { route };
+  const [baseTree, headTree, theirsTree] = await Promise.all([treeAt(gh, mergeBase), treeAt(gh, headSha), treeAt(gh, mainSha)]);
+  const config = await configAt(gh, mainSha, theirsTree) ?? await configAt(gh, mergeBase, baseTree);
+  const root = config?.tokens.root ?? guess;
+  const options = config ? layoutOptions(config) : {};
+  const checksPath = `${root}/${config?.tokens.contrastChecks ?? DEFAULT_TOKEN_PATHS.contrastChecks}`;
+  const [baseFiles, mineFiles, theirsFiles, checks] = await Promise.all([
+    tokenFilesAt(gh, mergeBase, root, baseTree),
+    tokenFilesAt(gh, headSha, root, headTree),
+    tokenFilesAt(gh, mainSha, root, theirsTree),
+    theirsTree.has(checksPath) ? textAt(gh, mainSha, checksPath) : Promise.resolve("")
+  ]);
+  const input = { base: baseFiles, mine: mineFiles, theirs: theirsFiles, files: route.files.map((f) => withoutRoot(root, f)) };
+  return {
+    route,
+    tokens: {
+      root,
+      plan: planTokenMerge(input),
+      input,
+      sets: { base: buildTokenSet(baseFiles, options), mine: buildTokenSet(mineFiles, options), theirs: buildTokenSet(theirsFiles, options) },
+      mineFiles,
+      theirsFiles,
+      pairs: parseContrastChecks(checks || opts.contrastFallback),
+      options
+    },
+    write: { mainSha, mainTree, headSha, headTree, changeFiles }
+  };
+}
+function resolvedTokenFiles(data, choices) {
+  const t = data.tokens;
+  const merged = applyTokenMerge(t.input, choices).files;
+  const all = { ...t.theirsFiles };
+  for (const f of data.write.changeFiles) {
+    for (const p of [f.previous_filename, f.filename]) {
+      if (!p || !p.endsWith(".tokens.json") || !p.startsWith(`${t.root}/`)) continue;
+      const rel = withoutRoot(t.root, p);
+      if (rel in merged) continue;
+      if (t.mineFiles[rel] === void 0) delete all[rel];
+      else all[rel] = t.mineFiles[rel];
+    }
+  }
+  for (const [rel, text] of Object.entries(merged)) {
+    if (text === null) delete all[rel];
+    else all[rel] = text;
+  }
+  return { all, merged };
+}
+async function commitLibraryResolution(gh, pull, data, choices, who) {
+  const t = data.tokens;
+  const w = data.write;
+  if (!t || !w) throw new Error("Only a token conflict can be resolved in Bridge. A developer resolves code conflicts on GitHub.");
+  if (w.headSha !== pull.head.sha) throw new Error("The branch moved while you were choosing. Read it again and resolve again.");
+  const { merged } = resolvedTokenFiles(data, choices);
+  const shared = new Set(data.route.files);
+  const tree = [];
+  for (const f of w.changeFiles) {
+    if (shared.has(f.filename)) continue;
+    if (f.previous_filename && !shared.has(f.previous_filename)) tree.push({ path: f.previous_filename, mode: "100644", sha: null });
+    if (f.status === "removed") {
+      tree.push({ path: f.filename, mode: "100644", sha: null });
+      continue;
+    }
+    const e = w.headTree.get(f.filename);
+    if (!e) throw new Error(`Bridge could not read ${f.filename} in the branch. Read it again and try again.`);
+    tree.push({ path: e.path, mode: e.mode, sha: e.sha });
+  }
+  for (const [rel, text] of Object.entries(merged)) {
+    const path = t.root ? `${t.root}/${rel}` : rel;
+    const mode = w.headTree.get(path)?.mode ?? "100644";
+    tree.push(text === null ? { path, mode, sha: null } : { path, mode, content: text });
+  }
+  const newTree = await gh.createTreeEntries(w.mainTree, tree);
+  const message = resolutionMessage({ library: pull.base.ref, conflicts: t.plan.conflicts, choices, who });
+  const commit = await gh.createCommit(message, newTree, [w.headSha, w.mainSha]);
+  await gh.updateBranch(pull.head.ref, commit);
+  return commit;
+}
+
+// ../core/src/branch-actions.ts
+async function mergeOnGitHub(gh, input) {
+  const r = await gh.mergePullRequest(input.number, { method: input.method ?? "squash", sha: input.headSha });
+  return { sha: r.sha };
+}
+var OverrideMergeError = class extends Error {
+  constructor(stage, message, cause, commentUrl) {
+    super(message);
+    this.stage = stage;
+    this.cause = cause;
+    this.commentUrl = commentUrl;
+    this.name = "OverrideMergeError";
+  }
+  stage;
+  cause;
+  commentUrl;
+};
+async function overrideMergeOnGitHub(gh, input) {
+  const body = overrideComment(input.login, input.reason, input.missing);
+  let comment;
+  try {
+    comment = await gh.createIssueComment(input.number, body);
+  } catch (err) {
+    throw new OverrideMergeError("comment", `GitHub did not take the comment, so nothing merged: ${err.message}`, err);
+  }
+  try {
+    const r = await gh.mergePullRequest(input.number, { method: input.method, sha: input.headSha, commitMessage: body.replace(OVERRIDE_HEADING, "").trim() });
+    return { sha: r.sha, commentUrl: comment.url, comment: body };
+  } catch (err) {
+    const msg = err.message.trim().replace(/[.\s]+$/, "");
+    await gh.updateIssueComment(comment.id, overrideRefusedComment(body, msg)).catch(() => void 0);
+    throw new OverrideMergeError(
+      "merge",
+      `GitHub refused to merge it: ${msg}. Your reason stays on the branch, marked not merged. The protection of main may need an approving review or an admin bypass.`,
+      err,
+      comment.url
+    );
+  }
+}
+async function reviewOnGitHub(gh, input) {
+  const text = input.body?.trim() ?? "";
+  if (input.event === "REQUEST_CHANGES" && !text) throw new Error("Add a comment that says what to change.");
+  if (input.event === "COMMENT" && !text) throw new Error("Write a comment first.");
+  return gh.submitReview(input.number, { event: input.event, body: text || void 0, commitId: input.headSha });
+}
+async function commentOnGitHub(gh, n, body) {
+  const text = body.trim();
+  if (!text) throw new Error("Write the comment first.");
+  return gh.createIssueComment(n, text);
+}
+async function askOthersToReviewOnGitHub(gh, input) {
+  if (!input.others.length) throw new Error("Nobody else can give the missing approval. Review it, or ask an owner in Settings to add a reviewer.");
+  await gh.requestReviewers(input.number, input.others);
+  if (input.viewer && input.viewerRequested) await gh.removeRequestedReviewers(input.number, [input.viewer]).catch(() => void 0);
+  return input.others;
+}
+async function closeOnGitHub(gh, n) {
+  await gh.updatePullRequest(n, { state: "closed" });
+}
+async function reopenOnGitHub(gh, n) {
+  await gh.updatePullRequest(n, { state: "open" });
+}
+var sameLogin = (a, b) => Boolean(a && b && a.toLowerCase().replace(/^@/, "") === b.toLowerCase().replace(/^@/, ""));
+function canAddTo(p, viewer, write) {
+  if (!viewer) return false;
+  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`);
+  return `${viewer ? `@${viewer} added` : "Added"} token edits from ${from}:
+
+${lines.join("\n")}`;
+}
+
+// ../core/src/jira.ts
+var JIRA_KEY = /^[A-Z][A-Z0-9_]{0,9}-[1-9]\d{0,6}$/;
+function parseJiraKey(input) {
+  const t = (input ?? "").trim().toUpperCase();
+  if (!t) return null;
+  if (!JIRA_KEY.test(t)) throw new Error("Write the Jira ticket as its key, like DS-42, or leave it empty.");
+  return t;
+}
+var LEADING_KEY = /^\[?([A-Z][A-Z0-9_]{0,9}-[1-9]\d{0,6})\]?[:\s]\s*/;
+var withoutJiraKey = (title) => title.trim().replace(LEADING_KEY, "");
+function titleWithJiraKey(title, key) {
+  if (!key) return title;
+  return `${key} ${withoutJiraKey(title)}`;
+}
+function branchWithJiraKey(branch, key) {
+  if (!key || branch.includes(key)) return branch;
+  const i = branch.lastIndexOf("/");
+  return i < 0 ? `${key}-${branch}` : `${branch.slice(0, i + 1)}${key}-${branch.slice(i + 1)}`;
+}
+
+// ../core/src/docs-proposal.ts
+var DOCS_EDITOR_ORIGIN = {
+  where: "in the Bridge docs editor",
+  footer: 'Proposed with the Bridge docs editor by a person (no AI involved in this text unless the docs say "draftedBy").',
+  label: "source: bridge-web"
+};
+var DOCS_MCP_ORIGIN = {
+  where: "with Claude through the Bridge MCP server",
+  footer: 'Proposed with the Bridge MCP server on behalf of a person. Docs Claude drafted say "draftedBy": "claude" until a reviewer accepts them.',
+  label: "source: mcp"
+};
+var EM_DASH = /\u2014/;
+function validateDocs(d) {
+  const out = [];
+  if (!d.summary.trim()) out.push({ field: "summary", message: "Add a summary: one or two sentences on what it is for." });
+  const lists = ["whenToUse", "whenNotToUse", "accessibility", "contentGuidelines"];
+  for (const k of lists) (d[k] ?? []).forEach((x, i) => !x.trim() && out.push({ field: `${k}.${i}`, message: "Fill or remove the empty item." }));
+  for (const k of ["dos", "donts"]) d[k].forEach((g, i) => (!g.title.trim() || !g.text.trim()) && out.push({ field: `${k}.${i}`, message: "Give every item a title and a sentence." }));
+  const prose = JSON.stringify([d.summary, d.whenToUse, d.whenNotToUse, d.dos, d.donts, d.accessibility, d.contentGuidelines ?? [], d.anatomy ?? {}]);
+  if (EM_DASH.test(prose)) out.push({ field: "voice", message: "Replace the em dashes with a colon, a comma or two sentences." });
+  return out;
+}
+function cleanDocs(d) {
+  const list = (xs) => (xs ?? []).map((x) => x.trim()).filter(Boolean);
+  const guide = (xs) => xs.map((g) => ({ ...g, title: g.title.trim(), text: g.text.trim() })).filter((g) => g.title || g.text);
+  return {
+    ...d,
+    summary: d.summary.trim(),
+    whenToUse: list(d.whenToUse),
+    whenNotToUse: list(d.whenNotToUse),
+    dos: guide(d.dos),
+    donts: guide(d.donts),
+    accessibility: list(d.accessibility),
+    contentGuidelines: list(d.contentGuidelines),
+    anatomy: Object.fromEntries(Object.entries(d.anatomy ?? {}).filter(([k, v]) => k.trim() && v.trim()))
+  };
+}
+var docsFileText = (d, original) => patchDocsJson(original, cleanDocs(d));
+var slugDate = (d) => d.toISOString().slice(0, 10).replace(/-/g, "");
+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 = `${names2.length === 1 ? edits[0].slug : `${edits[0].slug}-and-${names2.length - 1}-more`}`.toLowerCase().replace(/[^a-z0-9-]+/g, "-").slice(0, 40);
+  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";
+  const changeset = `---
+"${pkg}": patch
+---
+
+Usage guidance for ${list}.
+`;
+  const files = [...edits.map((e) => ({ path: e.path, content: e.after })), { path: csPath, content: changeset }];
+  const risk = classifyRisk({ files: files.map((f) => ({ path: f.path, status: "modified" })) });
+  const rows = edits.map((e) => {
+    let state = "edited";
+    try {
+      const d = JSON.parse(e.after);
+      const gaps = missingProse(d);
+      state = gaps.length ? `still missing: ${gaps.join(", ")}` : "every section filled";
+    } catch {
+      state = "not valid JSON";
+    }
+    return `- \`${e.path}\` (${e.before === null ? "new" : "changed"}, ${state})`;
+  });
+  const body = [
+    `## Docs change`,
+    "",
+    `Usage guidance for ${list}, written ${origin.where}.`,
+    "",
+    ...rows,
+    "",
+    `**Risk:** ${risk.label}. Docs only: the published components do not change. Changeset: patch.`,
+    "",
+    opts.notes?.trim() ? `## Notes
+
+${opts.notes.trim()}
+` : "",
+    "---",
+    origin.footer
+  ].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}`] };
+}
+async function proposeDocsOnGitHub(gh, edits, opts) {
+  const p = docsProposal(edits, { title: opts.title, notes: opts.notes, date: opts.date ?? /* @__PURE__ */ new Date(), origin: opts.origin });
+  const prTitle = titleWithJiraKey(p.title, opts.jira ?? null);
+  const branch = branchWithJiraKey(p.branch, opts.jira ?? null);
+  const mainSha = await gh.getBranchSha(opts.base);
+  if (!mainSha) throw new Error(`Branch ${opts.base} not found.`);
+  const tree = await gh.createTree(await gh.getCommitTree(mainSha), p.files.map((f) => ({ path: f.path, content: f.content })));
+  const commit = await gh.createCommit(`${prTitle}
+
+${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 };
+}
+async function commitFileOnGitHub(gh, input) {
+  const cur = await gh.getFile(input.path, input.branch);
+  if (!cur) throw new Error(`${input.path} is not on ${input.branch}. Check the component name and the branch.`);
+  const content = input.next(cur.text);
+  if (content === cur.text) return "";
+  return gh.putFile({ path: input.path, content, branch: input.branch, message: input.message, sha: cur.sha });
+}
+
+// ../core/src/share-branch.ts
+var packageDir = (name) => `packages/${name.replace(/^@[^/]+\//, "")}/`;
+function touchesPackages(files, packages) {
+  const dirs = packages.map(packageDir);
+  return files.some((f) => dirs.some((d) => f.startsWith(d)));
+}
+function shareState(x) {
+  if (!touchesPackages(x.files, x.packages)) return { kind: "no-packages" };
+  const c = readPreviewComment(x.comment);
+  if (x.lifecycle === "merged" || x.lifecycle === "closed") {
+    const kind = x.lifecycle === "merged" ? "shipped" : "closed";
+    if (!c || !c.command || c.source === "none") return { kind, stillWorks: null, command: null };
+    return { kind, stillWorks: c.source === "pkg.pr.new" ? true : c.source === "release" ? false : null, command: c.command };
+  }
+  if (!c) return { kind: "building" };
+  if (c.sha7 && !x.headSha.startsWith(c.sha7)) return { kind: "building" };
+  if (!c.command || c.source === "none") return { kind: "failed" };
+  return { kind: "ready", command: c.command, source: c.source };
+}
+var stableCommand = (packages) => `npm i ${packages.map((p) => `${p}@latest`).join(" ")}`;
+function stateSentence(s) {
+  switch (s.kind) {
+    case "ready":
+      return null;
+    case "building":
+      return "The preview version is being prepared. It is usually ready a couple of minutes after each update to the branch.";
+    case "failed":
+      return "The preview version could not be prepared for the latest update. Update the branch to try again, or ask a developer to run it again on GitHub.";
+    case "no-packages":
+      return "This branch does not touch the library tokens or components, so there is no preview version to install.";
+    case "shipped":
+      return s.stillWorks === true ? "This branch was merged. Its preview version still installs, and products get it with the next library release." : s.stillWorks === false ? "This branch was merged, so its preview version was removed. Products get it with the next library release." : "This branch was merged. Products get it with the next library release.";
+    case "closed":
+      return s.stillWorks === true ? "This branch was closed without merging. Its preview version still installs, but it will not reach the library." : s.stillWorks === false ? "This branch was closed without merging, so its preview version was removed." : "This branch was closed without merging.";
+  }
+}
+var quote = (t) => `"${t.trim().replace(/"/g, "'")}"`;
+function shareMessage(x) {
+  const back = stableCommand(x.packages);
+  const s = x.state;
+  if (s.kind === "ready") {
+    const lasts = s.source === "pkg.pr.new" ? "This preview stays available. Each update to the change makes a new one: ask me for the latest command." : "This preview is replaced on each update to the change and removed when it ships or closes: ask me for the latest command if the install fails.";
+    return {
+      subject: `Try the design system change ${quote(x.title)} before it ships`,
+      body: [
+        "Hi,",
+        "",
+        `Could you try the design system change ${quote(x.title)} in our product before it ships?`,
+        ...x.tryUrl ? ["", `See it in the demo product first: ${x.tryUrl}`] : [],
+        "",
+        "Install the preview version in a staging branch (not production):",
+        s.command,
+        "",
+        lasts,
+        "",
+        "To go back to the stable version:",
+        back,
+        "",
+        `Details for developers: ${x.url}`
+      ].join("\n")
+    };
+  }
+  if ((s.kind === "shipped" || s.kind === "closed") && s.command) {
+    const what = s.kind === "shipped" ? `The design system change ${quote(x.title)} has shipped. You get it with the next library release.` : `The design system change ${quote(x.title)} was closed without shipping.`;
+    const preview = s.stillWorks === false ? "Its preview version was removed, so reinstalling it fails." : s.stillWorks === true ? "Its preview version still installs, but it is not the released version." : "";
+    return {
+      subject: `Design system change ${quote(x.title)} ${s.kind === "shipped" ? "has shipped" : "was closed"}`,
+      body: ["Hi,", "", [what, preview].filter(Boolean).join(" "), "", "If you installed its preview, go back to the stable version:", back, "", `Details for developers: ${x.url}`].join("\n")
+    };
+  }
+  return null;
+}
+
+// ../core/src/try-in-product.ts
+function tryInProductUrl(preview, pr, screen) {
+  const url = new URL(preview);
+  url.pathname = "/";
+  url.search = "";
+  url.searchParams.set("bridge", String(pr));
+  if (screen) {
+    url.searchParams.set("tenant", screen.tenant);
+    url.searchParams.set("theme", screen.theme);
+  }
+  url.hash = screen ? screen.route : "";
+  return url.href;
+}
+
+// ../core/src/combine-branches.ts
+var MIN_TOGETHER = 2;
+var MAX_TOGETHER = 4;
+function onlyTokens(files, tokensRoot) {
+  const root = `${tokensRoot.replace(/^\/+|\/+$/g, "")}/`;
+  return files.length > 0 && files.every((f) => f.startsWith(root) && f.endsWith(".tokens.json") || /contrast\.checks\.json$/.test(f) || f.startsWith(".changeset/"));
+}
+function tokenFilesOf(files, tokensRoot) {
+  const root = `${tokensRoot.replace(/^\/+|\/+$/g, "")}/`;
+  return files.filter((f) => f.startsWith(root) && f.endsWith(".tokens.json")).map((f) => f.slice(root.length));
+}
+var changeList = (numbers) => numbers.join(",");
+function tryTogetherUrl(admin, numbers, picks) {
+  const url = new URL(admin);
+  url.pathname = "/";
+  url.hash = "";
+  const use = encodePicks(picks);
+  url.search = `?bridge=${changeList(numbers)}${use ? `&bridge-use=${encodeURIComponent(use)}` : ""}`;
+  return url.href;
+}
+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 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 };
+  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]) };
+  await Promise.all(
+    tokenFiles.map(async (f) => {
+      const rel = tokenFilesOf([f.filename], root)[0];
+      source.base[rel] = f.status === "added" ? void 0 : await gh.readFile(f.previous_filename ?? f.filename, start);
+      source.head[rel] = f.status === "removed" ? void 0 : await gh.readFile(f.filename, pull.headSha);
+    })
+  );
+  return { number: pull.number, title: pull.title, tokens: true, edits: changeEdits(source) };
+}
+
 // ../core/src/node/git-history.ts
 var US = "";
 var RS = "";
@@ -4344,7 +5648,8 @@ function classifyTag(t, imports, ds) {
     if (name === "a" && !t.hasHref) return {};
     if (t.inRenderProp) return {};
     const suggestion = nativeEquivalent(name, t.type, ds.components);
-    return { component: { ...at, name, kind: "native", library: "native", ...suggestion ? { suggestion } : {} } };
+    if (!suggestion) return {};
+    return { component: { ...at, name, kind: "native", library: "native", suggestion } };
   }
   const root = name.split(".")[0];
   const imp = imports.get(root);
@@ -5398,9 +6703,9 @@ var DesignSystemIndex = class {
         return generic ? this.make(generic, 1, 0.3) : void 0;
       }
       case "shadow": {
-        const norm = (s) => s.replace(/\s+/g, " ").replace(/\s*,\s*/g, ", ").trim().toLowerCase();
+        const norm2 = (s) => s.replace(/\s+/g, " ").replace(/\s*,\s*/g, ", ").trim().toLowerCase();
         const cands = this.entries(["shadow"]);
-        const exact = cands.find((e) => norm(e.css) === norm(value));
+        const exact = cands.find((e) => norm2(e.css) === norm2(value));
         if (exact) return this.make(exact, 0, 1);
         const t = shadowNums(value);
         const scored = cands.map((e) => {
@@ -5826,11 +7131,11 @@ async function listComponentNames(source, config) {
 }
 var findFamily = (stories) => stories ? /title:\s*['"]([^'"/]+)\//.exec(stories)?.[1] : void 0;
 async function listComponents(source, config, withSummaries) {
-  const names = await listComponentNames(source, config);
-  if (!withSummaries) return names.map((n) => ({ name: n.name }));
+  const names2 = await listComponentNames(source, config);
+  if (!withSummaries) return names2.map((n) => ({ name: n.name }));
   const dir = config.components.dir;
   return Promise.all(
-    names.map(async ({ name, files }) => {
+    names2.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]);
@@ -6285,6 +7590,454 @@ __export(explorations_exports, {
 });
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { dirname as dirname2, join as join3 } from "node:path";
+
+// src/branches.ts
+var branches_exports = {};
+__export(branches_exports, {
+  RIGHTS: () => RIGHTS,
+  addableBranch: () => addableBranch,
+  askSomeoneElse: () => askSomeoneElse,
+  backToDraft: () => backToDraft,
+  branchFacts: () => branchFacts,
+  branchNumber: () => branchNumber,
+  branchStatus: () => branchStatus,
+  closeBranch: () => closeBranch,
+  combineBranches: () => combineBranches,
+  commentOnBranch: () => commentOnBranch,
+  listComments: () => listComments,
+  listProducts: () => listProducts,
+  mergeBranch: () => mergeBranch,
+  productMarks: () => productMarks,
+  reopenBranch: () => reopenBranch,
+  resolveProduct: () => resolveProduct,
+  reviewBranch: () => reviewBranch,
+  sendForReview: () => sendForReview,
+  tryBranch: () => tryBranch,
+  updateFromMain: () => updateFromMain,
+  whatNeedsMe: () => whatNeedsMe
+});
+import { relative as relative2 } from "node:path";
+var RIGHTS = {
+  review: "Pull requests: read and write",
+  comment: "Pull requests (or Issues): read and write",
+  merge: "Contents and Pull requests: read and write, and the right to ship in bridge.config.json (governance.rights)",
+  update: "Contents and Pull requests: read and write",
+  draft: "Pull requests: read and write (you must be the author, as in Studio)",
+  docs: "Contents and Pull requests: read and write"
+};
+var NO_REPO = 'No GitHub repo known: set "repo" in bridge.config.json or add an origin remote.';
+async function reader(ctx) {
+  const gh = await ctx.github();
+  if (!gh) throw new Error(NO_REPO);
+  return gh;
+}
+async function writer(ctx, what, need) {
+  const gh = await reader(ctx);
+  if (!ctx.canWriteRemote) throw new Error(`${what} needs a GitHub token with ${need} on ${gh.fullName}. Set GITHUB_TOKEN (or BRIDGE_GITHUB_TOKEN) where the Bridge MCP server or the CLI runs, or do it in Bridge Studio.`);
+  return gh.withBranchPrefix(void 0);
+}
+function branchNumber(input) {
+  if (typeof input === "number" && Number.isInteger(input) && input > 0) return input;
+  const m = /^#?(\d+)$/.exec(String(input).trim()) ?? /\/pull\/(\d+)/.exec(String(input));
+  if (!m) throw new Error(`"${input}" is not a branch number. Pass the number Studio shows (#12) or the link of the branch on GitHub.`);
+  return Number(m[1]);
+}
+var lifecycleOf = (state, draft) => state === "merged" ? "merged" : state === "closed" ? "closed" : draft ? "draft" : "open";
+async function people(gh, config) {
+  const { owners, rights } = config.governance;
+  const teams = await new TeamDirectory(gh).resolve(owners).catch(() => void 0);
+  const lists = expandOwners(approverEntries(owners, rights), teams);
+  return { lists, ship: shipPolicy(owners, rights, teams) };
+}
+async function viewerOf(ctx, gh) {
+  if (!ctx.canWriteRemote) return null;
+  return gh.getViewer().then((v) => v.login, () => null);
+}
+async function branchFacts(ctx, gh, n, viewer) {
+  const { config } = await ctx.config();
+  const pr = await gh.getPullRequest(n);
+  const [files, reviews, runs, statuses, who, compare, repo] = await Promise.all([
+    gh.listPullRequestFiles(n),
+    gh.listReviews(n).catch(() => []),
+    gh.listCheckRuns(pr.headSha).catch(() => []),
+    gh.listCommitStatuses(pr.headSha).catch(() => []),
+    people(gh, config),
+    pr.state === "open" ? gh.compareDetailed(pr.baseRef, pr.headSha).catch(() => null) : Promise.resolve(null),
+    viewer ? gh.getMergeSettings().catch(() => null) : Promise.resolve(null)
+  ]);
+  const labels = pr.labels.map((name) => ({ name }));
+  const ci = summarizeCi(
+    runs.map((r) => ({ name: r.name, status: r.status, conclusion: r.conclusion, ...r.url ? { html_url: r.url } : {} })),
+    statuses.map((s) => ({ context: s.context, state: s.state, target_url: s.target_url }))
+  );
+  const approvals = summarizeApprovals(
+    reviews.map((r) => ({ user: r.user ? { login: r.user } : null, state: r.state, submitted_at: r.submittedAt ?? null })),
+    who.lists,
+    pr.author
+  );
+  const tier = effectiveTier(labels, pr.body, files);
+  const merged = pr.state === "merged";
+  const pullLike = { state: merged ? "closed" : pr.state, draft: pr.draft, merged_at: merged ? "merged" : null };
+  const exploration = isActiveExploration(pr.labels);
+  const gate = mergeGate({ tier, ci, approvals, draft: pr.draft, mergeable: pr.mergeable, state: pullLike.state, merged_at: pullLike.merged_at, viewer, override: config.governance.override, exploration, ship: who.ship });
+  const status = reviewStatusKind({ ...pullLike, ci, approvals, tier, mergeable: pr.mergeable });
+  const fresh = freshness({ compare: compare ? { behind_by: compare.behindBy, merge_base_commit: compare.mergeBase ? { sha: compare.mergeBase } : null } : null, mergeable: pr.mergeable, open: pr.state === "open" });
+  const product = productOfBranch(productsOf(config), { files: files.map((f) => f.filename), labels: pr.labels });
+  return { config, pr, files, ci, approvals, tier, gate, status, fresh, compare, exploration, product, lifecycle: pullState(pullLike), write: repo ? hasWriteAccess(repo.permissions) : null, repo };
+}
+var STATUS_WORDS = {
+  merged: "Merged",
+  closed: "Closed",
+  draft: "Draft",
+  "ci-failing": "Blocked by tests",
+  "changes-requested": "Changes requested",
+  "ci-running": "Tests running",
+  "needs-design": "Needs design approval",
+  "needs-tech": "Needs tech approval",
+  "needs-approval": "Needs approval",
+  conflict: "Conflict with main",
+  checking: "Checking",
+  ready: "Ready to merge",
+  unknown: "Status unknown"
+};
+async function branchStatus(ctx, a) {
+  const n = branchNumber(a.pr);
+  const gh = await reader(ctx);
+  const viewer = await viewerOf(ctx, gh);
+  const f = await branchFacts(ctx, gh, n, viewer);
+  return {
+    pr: n,
+    title: f.pr.title,
+    url: f.pr.url,
+    author: f.pr.author,
+    product: { key: f.product.key, name: f.product.name },
+    lifecycle: f.lifecycle,
+    status: { kind: f.status, label: STATUS_WORDS[f.status] },
+    approvalNeeded: f.tier === 1 ? "One approval" : "Design and tech approval",
+    approvals: { approvedBy: f.approvals.approvers, changesRequestedBy: f.approvals.changesRequested, design: f.approvals.design, tech: f.approvals.tech },
+    tests: { state: f.ci.state, failing: f.ci.failed.map((x) => x.name), running: f.ci.pending.map((x) => x.name) },
+    main: { state: f.fresh.state, behindBy: f.fresh.behindBy },
+    merge: {
+      allowed: f.gate.allowed,
+      blockedBy: f.gate.reasons,
+      ...viewer ? { you: viewer, youCanShip: f.gate.canShip, ownerOverride: f.gate.overridable } : { you: null, note: "Without a GitHub token Bridge cannot tell whether you may merge." }
+    },
+    next: nextStep(f, viewer)
+  };
+}
+function nextStep(f, viewer) {
+  if (f.lifecycle === "merged") return "Merged. It goes out with the next library release.";
+  if (f.lifecycle === "closed") return "Closed without merging. bridge_reopen_branch reopens it when its work is still there.";
+  if (f.exploration) return "It is an exploration: promote it with bridge_promote_exploration when the idea is validated, or close it.";
+  if (f.lifecycle === "draft") return "Draft: bridge_send_for_review asks for review when it is ready.";
+  if (f.fresh.state === "conflict") return "It conflicts with main: bridge_update_from_main shows the token conflicts to pick (code conflicts stay with a developer).";
+  if (f.gate.allowed) return viewer ? "Ready: bridge_merge_branch merges it when the person asks." : "Ready to merge by someone who may ship.";
+  if (f.gate.overridable) return `Only approvals are missing and you may use the owner override: bridge_merge_branch with a reason of at least ${(f.config.governance.override ?? DEFAULT_OVERRIDE).minReasonLength} characters.`;
+  return f.gate.reasons[0] ?? "Waiting.";
+}
+async function whatNeedsMe(ctx, a = {}) {
+  const gh = await reader(ctx);
+  const { config } = await ctx.config();
+  const viewer = await viewerOf(ctx, gh);
+  const pulls = await gh.listPullRequests("open");
+  const queue = reviewQueue(pulls.map((p) => ({ ...p, state: p.state, head: { ref: p.headRef }, user: { login: p.author }, labels: p.labels.map((name) => ({ name })) }))).slice(0, a.limit ?? 20);
+  const who = await people(gh, config);
+  const same2 = (x, y) => Boolean(y && x.toLowerCase() === y.toLowerCase());
+  const rows = await Promise.all(
+    queue.map(async (p) => {
+      const f = await branchFacts(ctx, gh, p.number, viewer).catch(() => null);
+      if (!f) return { pr: p.number, title: p.title, url: p.url, author: p.author, status: "unknown", statusLabel: STATUS_WORDS.unknown, yours: same2(p.author, viewer), needsYou: null };
+      const mine = same2(p.author, viewer);
+      const inDesign = viewer ? who.lists.design.some((x) => same2(x, viewer)) : false;
+      const inTech = viewer ? who.lists.tech.some((x) => same2(x, viewer)) : false;
+      let needsYou = null;
+      if (viewer && !mine) {
+        if (f.status === "needs-design" && inDesign) needsYou = "Your design approval";
+        else if (f.status === "needs-tech" && inTech) needsYou = "Your tech approval";
+        else if (f.status === "needs-approval" && !f.approvals.approvers.some((x) => same2(x, viewer))) needsYou = "Your approval";
+        else if (f.status === "ready" && f.gate.canShip) needsYou = "Ready for you to merge";
+      }
+      if (viewer && mine) {
+        if (f.status === "changes-requested") needsYou = "Changes requested on your branch";
+        else if (f.status === "ci-failing") needsYou = "Tests fail on your branch";
+        else if (f.status === "conflict") needsYou = "Your branch conflicts with main";
+        else if (f.status === "ready" && f.gate.canShip) needsYou = "Your branch is ready to merge";
+      }
+      return { pr: p.number, title: p.title, url: p.url, author: p.author, product: f.product.name, status: f.status, statusLabel: STATUS_WORDS[f.status], yours: mine, needsYou };
+    })
+  );
+  rows.sort((x, y) => Number(Boolean(y.needsYou)) - Number(Boolean(x.needsYou)) || REVIEW_STATUS_ORDER[x.status] - REVIEW_STATUS_ORDER[y.status]);
+  const mineCount = rows.filter((r) => r.needsYou).length;
+  return {
+    viewer,
+    summary: viewer ? `${mineCount ? `${mineCount} ${mineCount === 1 ? "branch needs" : "branches need"} you` : "Nothing needs you right now"}; ${rows.length} in review.` : `${rows.length} in review. Set a GitHub token so Bridge knows which ones need you.`,
+    branches: rows
+  };
+}
+async function listProducts(ctx) {
+  const { config } = await ctx.config();
+  const products = productsOf(config);
+  const here = await productHere(ctx, config);
+  return {
+    products: products.map((p) => ({ key: p.key, name: p.name, ...p.repo ? { repo: p.repo } : {}, ...p.path ? { path: p.path } : {}, ...p.preview ? { preview: p.preview } : {}, ...p.framework ? { framework: p.framework } : {}, default: p === defaultProduct(products) })),
+    current: { key: here.product.key, name: here.product.name, how: here.how },
+    howToPick: 'Pass "product" (key or name) to the tools that start work. Without it Bridge uses the product of the current folder or repo, else the default product. Ask the person when it is not obvious.'
+  };
+}
+async function productHere(ctx, config) {
+  const products = productsOf(config);
+  if (ctx.mode !== "local" || !ctx.root) return productForPlace(products, {});
+  const cwd = process.cwd();
+  const rel = relative2(ctx.root, cwd);
+  const repo = await originRepo(cwd).catch(() => void 0);
+  const ds = config.repo ? `${config.repo.owner}/${config.repo.name}` : await originRepo(ctx.root).catch(() => void 0);
+  return productForPlace(products, { relPath: rel.startsWith("..") ? null : rel, repo: repo ?? null, designSystemRepo: ds ?? null });
+}
+async function resolveProduct(ctx, name) {
+  const { config } = await ctx.config();
+  const products = productsOf(config);
+  if (name?.trim()) {
+    const p = findProduct(products, name);
+    if (!p) throw new Error(`Unknown product "${name}". Pick one of: ${products.map((x) => `${x.key} (${x.name})`).join(", ")}. Products are listed in bridge.config.json "products".`);
+    return p;
+  }
+  return (await productHere(ctx, config)).product;
+}
+function productMarks(products, p) {
+  if (p.key === defaultProduct(products).key) return { labels: [], line: "" };
+  return { labels: [productLabel(p.key)], line: `**Product:** ${p.name}` };
+}
+async function tryBranch(ctx, a) {
+  const n = branchNumber(a.pr);
+  const gh = await reader(ctx);
+  const { config } = await ctx.config();
+  const pr = await gh.getPullRequest(n);
+  const [files, comments] = await Promise.all([gh.listPullRequestFiles(n), gh.listIssueComments(n).catch(() => [])]);
+  const previews = await branchPreviewUrls(gh, n, config, { branch: pr.headRef, sha: pr.headSha, comments }).catch(() => []);
+  const apps = config.previews?.apps ?? {};
+  const products = productsOf(config).map((p) => {
+    const app = Object.entries(apps).find(([, t]) => t && t === p.preview)?.[0];
+    const hit = app ? previews.find((x) => x.app === app && x.url && x.source !== "template" && x.state !== "failed") : void 0;
+    const reported = hit?.url ?? null;
+    const pattern = !app && p.preview ? previewUrl(p.preview, { branch: pr.headRef, pr: n, sha: pr.headSha }) : null;
+    const url = reported ? app === "admin" ? tryInProductUrl(reported, n, null) : reported : pattern;
+    return { key: p.key, name: p.name, url, how: reported ? "reported by Vercel" : pattern ? "from the preview pattern in bridge.config.json (it may not exist yet)" : "no preview reported yet" };
+  });
+  const lifecycle = lifecycleOf(pr.state, pr.draft);
+  const packages = config.previews?.packages ?? [];
+  const share = shareState({ lifecycle, files: files.map((f) => f.filename), packages, comment: comments.find((c) => c.body.includes("<!-- bridge-branch-preview -->"))?.body, headSha: pr.headSha });
+  const tryUrl = products.find((p) => p.url && p.how === "reported by Vercel")?.url ?? null;
+  const message = shareMessage({ title: pr.title, state: share, packages, tryUrl, url: pr.url });
+  return {
+    pr: n,
+    title: pr.title,
+    tryInProduct: products,
+    previews: previews.map((p) => ({ app: p.app, label: p.label, url: p.url, state: p.state })),
+    share: {
+      state: share.kind,
+      install: share.kind === "ready" ? share.command : null,
+      sentence: stateSentence(share) ?? "Product teams can install this branch in their app before it is merged, and remove it any time.",
+      ...message ? { message } : {}
+    }
+  };
+}
+async function combineBranches(ctx, a) {
+  const numbers = [...new Set(a.prs.map(branchNumber))];
+  if (numbers.length < MIN_TOGETHER || numbers.length > MAX_TOGETHER) throw new Error(`Pick ${MIN_TOGETHER} to ${MAX_TOGETHER} branches to try together (you gave ${numbers.length}).`);
+  const gh = await reader(ctx);
+  const { config } = await ctx.config();
+  const base = baseBranchOf(config);
+  const root = config.tokens.root;
+  const pulls = await Promise.all(numbers.map((n) => gh.getPullRequest(n)));
+  const branches = await Promise.all(pulls.map((p) => readCombineBranch(gh, { number: p.number, title: p.title, headSha: p.headSha }, { base, tokensRoot: root })));
+  const code2 = branches.filter((b) => !b.tokens);
+  if (code2.length) throw new Error(`#${code2.map((b) => b.number).join(", #")} ${code2.length === 1 ? "changes" : "change"} code, so ${code2.length === 1 ? "it" : "they"} can't be combined here. Pick branches that only change tokens.`);
+  const latest = {};
+  const files = (await gh.listFiles(base)).filter((f) => f.startsWith(`${root}/`) && f.endsWith(".tokens.json"));
+  await Promise.all(files.map(async (f) => latest[f.slice(root.length + 1)] = await gh.readFile(f, base) ?? ""));
+  const picks = a.picks ?? {};
+  const combo = combineChanges(latest, branches.map((b) => b.edits), picks);
+  const titles = new Map(pulls.map((p) => [p.number, p.title]));
+  const admin = config.previews?.production?.admin;
+  const docs = config.previews?.production?.docs;
+  return {
+    branches: pulls.map((p) => ({ pr: p.number, title: p.title })),
+    tokens: combo.tokens,
+    conflicts: combo.conflicts.map((c) => ({ key: c.key, token: c.path, file: c.file, options: c.options.map((o) => ({ use: o.changes[0], titles: o.changes.map((x) => titles.get(x) ?? `#${x}`) })), picked: picks[c.key] ?? null })),
+    missingPicks: combo.missing.length,
+    problems: combo.problems,
+    open: {
+      ...admin ? { product: tryTogetherUrl(admin, numbers, picks) } : {},
+      ...docs ? { library: `${docs.replace(/\/$/, "")}/?change=${numbers.join(",")}` } : {}
+    },
+    next: combo.missing.length ? `Pick a value for ${combo.missing.length} token${combo.missing.length === 1 ? "" : "s"}: pass picks {"<key>": <branch number>}.` : "Open the links to see them together. Nothing was written."
+  };
+}
+async function sendForReview(ctx, a) {
+  const n = branchNumber(a.pr);
+  const gh = await writer(ctx, "Sending a branch for review", RIGHTS.draft);
+  const [pr, viewer] = await Promise.all([gh.getPullRequest(n), gh.getViewer()]);
+  if (pr.author.toLowerCase() !== viewer.login.toLowerCase()) throw new Error(`Only its author (@${pr.author}) sends #${n} for review, as in Studio. Ask them, or comment with bridge_comment.`);
+  if (isActiveExploration(pr.labels)) throw new Error(`#${n} is an exploration: promote it with bridge_promote_exploration instead.`);
+  if (pr.state !== "open") throw new Error(`#${n} is ${pr.state}: reopen it first with bridge_reopen_branch.`);
+  if (!pr.draft) return { pr: n, status: "already-in-review", said: "It is already in review. Reviewers can see it." };
+  await gh.markReadyForReview(n);
+  return { pr: n, status: "in-review", said: "Review requested. Reviewers can see it now.", url: pr.url };
+}
+async function backToDraft(ctx, a) {
+  const n = branchNumber(a.pr);
+  const gh = await writer(ctx, "Taking a branch back to draft", RIGHTS.draft);
+  const [pr, viewer] = await Promise.all([gh.getPullRequest(n), gh.getViewer()]);
+  if (pr.author.toLowerCase() !== viewer.login.toLowerCase()) throw new Error(`Only its author (@${pr.author}) takes #${n} back to draft, as in Studio.`);
+  if (isActiveExploration(pr.labels)) throw new Error(`#${n} is an exploration: it is a draft until promoted.`);
+  await gh.convertToDraft(n);
+  return { pr: n, status: "draft", said: "Back to draft. Reviewers are not asked until you send it for review again." };
+}
+async function reviewBranch(ctx, a) {
+  const n = branchNumber(a.pr);
+  const gh = await writer(ctx, "Reviewing a branch", RIGHTS.review);
+  const pr = await gh.getPullRequest(n);
+  const event = { approve: "APPROVE", request_changes: "REQUEST_CHANGES", comment: "COMMENT" }[a.decision];
+  const r = await reviewOnGitHub(gh, { number: n, event, body: a.body, headSha: pr.headSha });
+  const said = { APPROVE: "Approved.", REQUEST_CHANGES: "Changes requested.", COMMENT: "Comment posted." }[event];
+  return { pr: n, decision: a.decision, id: r.id, said, note: event === "APPROVE" ? "Recorded under your GitHub account, on the version you saw." : void 0 };
+}
+async function askSomeoneElse(ctx, a) {
+  const n = branchNumber(a.pr);
+  const gh = a.dryRun ? await reader(ctx) : await writer(ctx, "Asking someone else to review", RIGHTS.review);
+  const viewer = await viewerOf(ctx, gh);
+  const f = await branchFacts(ctx, gh, n, viewer);
+  if (f.lifecycle !== "open") throw new Error(`#${n} is ${f.lifecycle === "draft" ? "a draft: send it for review first" : f.lifecycle}, so there is no review to ask for.`);
+  const { lists } = await people(gh, f.config);
+  const others = reviewersToAsk({ tier: f.tier, approvals: f.approvals, owners: lists, author: f.pr.author, viewer });
+  if (!others.length) throw new Error("Nobody else can give the missing approval. Review it, or ask an owner in Settings to add a reviewer.");
+  if (a.dryRun) return { pr: n, status: "would-ask", asks: others.map((l) => `@${l}`), said: `Would ask ${others.map((l) => `@${l}`).join(", ")} to review.` };
+  await askOthersToReviewOnGitHub(gh, { number: n, others, viewer, viewerRequested: Boolean(viewer && f.pr.requestedReviewers.some((r) => r.toLowerCase() === viewer.toLowerCase())) });
+  return { pr: n, status: "asked", asked: others.map((l) => `@${l}`), said: `Asked ${others.map((l) => `@${l}`).join(", ")} to review.` };
+}
+async function commentOnBranch(ctx, a) {
+  const n = branchNumber(a.pr);
+  const text = a.body.trim();
+  if (!text) throw new Error("Write the comment first.");
+  const gh = await writer(ctx, "Commenting on a branch", RIGHTS.comment);
+  if (a.replyTo) {
+    const r2 = await gh.replyToReviewComment(n, a.replyTo, text);
+    return { pr: n, replied: a.replyTo, url: r2.url, said: "Reply posted in the thread." };
+  }
+  const r = await commentOnGitHub(gh, n, text);
+  return { pr: n, url: r.url, said: "Comment posted." };
+}
+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(() => [])]);
+  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 })) })),
+    howToReply: "bridge_comment with replyTo: the thread id."
+  };
+}
+async function mergeBranch(ctx, a) {
+  const n = branchNumber(a.pr);
+  const gh = await writer(ctx, "Merging a branch", RIGHTS.merge);
+  const viewer = (await gh.getViewer()).login;
+  const f = await branchFacts(ctx, gh, n, viewer);
+  const policy = f.config.governance.override ?? DEFAULT_OVERRIDE;
+  const reason = a.overrideReason?.trim();
+  if (f.write === false) throw new Error(`@${viewer} cannot write to ${gh.fullName}, so GitHub refuses the merge. Ask someone with write access.`);
+  if (f.gate.allowed) {
+    if (a.dryRun) return { pr: n, status: "would-merge", said: "Every rule passes: it can be merged." };
+    const r = await mergeOnGitHub(gh, { number: n, headSha: f.pr.headSha, method: "squash" });
+    return { pr: n, status: "merged", sha: r.sha, said: "Merged. It goes out with the next library release." };
+  }
+  if (!reason) {
+    const hint = f.gate.overridable ? ` Only approvals are missing and @${viewer} may use the owner override: pass overrideReason (at least ${policy.minReasonLength} characters), it is posted on the branch.` : "";
+    throw new Error(`#${n} cannot be merged yet: ${f.gate.reasons.join(" ")}${hint}`);
+  }
+  if (!canOverride(viewer, policy)) throw new Error(`@${viewer} is not allowed to use the owner override (governance.override.allowed in bridge.config.json). It still needs: ${f.gate.missing.join(", ") || f.gate.reasons.join(" ")}`);
+  if (!f.gate.overridable) throw new Error(`The owner override only skips missing approvals. #${n} is blocked by: ${f.gate.reasons.join(" ")}`);
+  const problem = overrideReasonProblem(reason, policy);
+  if (problem) throw new Error(problem);
+  if (a.dryRun) return { pr: n, status: "would-override", skips: f.gate.missing, said: "The override would post your reason on the branch, then merge." };
+  const method = allowedMergeMethods(f.repo)[0] ?? "squash";
+  try {
+    const r = await overrideMergeOnGitHub(gh, { number: n, headSha: f.pr.headSha, login: viewer, reason, missing: f.gate.missing, method });
+    return { pr: n, status: "merged", override: true, sha: r.sha, reasonUrl: r.commentUrl, said: `Merged as owner override. The reason is on #${n}.` };
+  } catch (err) {
+    if (err instanceof OverrideMergeError) throw new Error(err.message);
+    throw err;
+  }
+}
+async function closeBranch(ctx, a) {
+  const n = branchNumber(a.pr);
+  const gh = await writer(ctx, "Closing a branch", RIGHTS.review);
+  const pr = await gh.getPullRequest(n);
+  if (isActiveExploration(pr.labels)) throw new Error(`#${n} is an exploration: close it with bridge_close_exploration.`);
+  if (pr.state !== "open") return { pr: n, status: pr.state, said: `It is already ${pr.state}.` };
+  await closeOnGitHub(gh, n);
+  return { pr: n, status: "closed", said: "Closed. It can be reopened while its work is still there." };
+}
+async function reopenBranch(ctx, a) {
+  const n = branchNumber(a.pr);
+  const gh = await writer(ctx, "Reopening a branch", RIGHTS.review);
+  const { config } = await ctx.config();
+  const [pr, viewer, repo] = await Promise.all([gh.getPullRequest(n), gh.getViewer(), gh.getMergeSettings().catch(() => null)]);
+  if (pr.state === "merged") throw new Error(`#${n} is merged: it cannot be reopened. Undo it with bridge_plan_revert and bridge_propose_revert.`);
+  const exists = await gh.getBranchSha(pr.headRef).then((s) => s ? "exists" : "gone", () => "unknown");
+  const owners = [...config.governance.owners.design, ...config.governance.owners.tech];
+  const ok2 = reopenEligibility({ state: pr.state === "closed" ? "closed" : "open", viewer: viewer.login, author: pr.author, owners, canWrite: hasWriteAccess(repo?.permissions), branch: exists });
+  if (pr.state === "open") return { pr: n, status: "open", said: "It is already open." };
+  if (ok2.kind === "gone") throw new Error(`#${n} can't be reopened: its work was removed. Start a new branch with its token edits (bridge_propose_token_change).`);
+  if (ok2.kind !== "reopen") throw new Error(`Only its author (@${pr.author}) or an owner with write access reopens #${n}, as in Studio.`);
+  await reopenOnGitHub(gh, n);
+  return { pr: n, status: "open", said: "Reopened. It is back in review with its earlier approvals and checks." };
+}
+async function updateFromMain(ctx, a) {
+  const n = branchNumber(a.pr);
+  const gh = a.dryRun ? await reader(ctx) : await writer(ctx, "Updating a branch from main", RIGHTS.update);
+  const { config } = await ctx.config();
+  const pr = await gh.getPullRequest(n);
+  if (pr.state !== "open") throw new Error(`#${n} is ${pr.state}: only an open branch is updated from main.`);
+  const compare = await gh.compareDetailed(pr.baseRef, pr.headSha);
+  const fresh = freshness({ compare: { behind_by: compare.behindBy, merge_base_commit: compare.mergeBase ? { sha: compare.mergeBase } : null }, mergeable: pr.mergeable, open: true });
+  if (fresh.state === "current") return { pr: n, status: "up-to-date", said: `It already has the latest ${pr.baseRef}.` };
+  if (fresh.state === "behind") {
+    if (a.dryRun) return { pr: n, status: "would-update", behindBy: fresh.behindBy, said: `${pr.baseRef} has ${fresh.behindBy} new update${fresh.behindBy === 1 ? "" : "s"}; nothing conflicts.` };
+    await gh.updatePullRequestBranch(n, pr.headSha);
+    return { pr: n, status: "updated", said: `Updated from ${pr.baseRef}. Checks run again; approvals may need renewing.` };
+  }
+  if (fresh.state === "unknown") throw new Error(`GitHub has not said yet whether #${n} merges cleanly. Try again in a minute.`);
+  const data = await readLibraryConflicts(gh, compare, pr.headSha, { tokensRoot: config.tokens.root });
+  if (data.route.kind === "code" || !data.tokens) {
+    throw new Error(`#${n} conflicts with ${pr.baseRef} in code${data.route.files.length ? ` (${data.route.files.slice(0, 5).join(", ")})` : ""}. A developer resolves that on GitHub: ${pr.url}`);
+  }
+  const conflicts = data.tokens.plan.conflicts.map((c) => ({ key: c.key, token: c.path, file: c.file, mine: c.mine ?? null, theirs: c.theirs ?? null, default: c.defaultChoice }));
+  const choices = a.choices ?? {};
+  const missing = missingChoices(data.tokens.plan, choices);
+  if (a.dryRun || missing.length) {
+    return {
+      pr: n,
+      status: "token-conflicts",
+      conflicts,
+      missing: missing.map((c) => c.key),
+      said: missing.length ? `${missing.length} token${missing.length === 1 ? "" : "s"} changed here and on ${pr.baseRef} without a default: pick "mine" or "theirs" for each key in choices.` : `${conflicts.length} token conflict${conflicts.length === 1 ? "" : "s"}; pass choices ("mine" keeps this branch, "theirs" uses ${pr.baseRef}) or run without dryRun to keep the defaults.`
+    };
+  }
+  const viewer = await gh.getViewer().then((v) => v.login, () => null);
+  const sha = await commitLibraryResolution(gh, { head: { ref: pr.headRef, sha: pr.headSha }, base: { ref: pr.baseRef } }, data, choices, viewer);
+  return { pr: n, status: "resolved", commit: sha, said: `Brought in the latest ${pr.baseRef} with your token choices. Checks run again.` };
+}
+async function addableBranch(ctx, n) {
+  const gh = await writer(ctx, "Adding edits to a branch", RIGHTS.update);
+  const [pr, viewer, repo] = await Promise.all([gh.getPullRequest(n), gh.getViewer(), gh.getMergeSettings().catch(() => null)]);
+  if (pr.state !== "open") throw new Error(`#${n} is ${pr.state}: only an open branch takes more edits. Start a new one instead.`);
+  if (isActiveExploration(pr.labels)) throw new Error(`#${n} is an exploration: pass branch "${pr.headRef}" instead of pr.`);
+  if (!canAddTo({ user: { login: pr.author } }, viewer.login, hasWriteAccess(repo?.permissions))) throw new Error(`Only its author (@${pr.author}) or someone with write access adds edits to #${n}.`);
+  return { gh, pr, viewer: viewer.login, comment: (paths) => addedComment(paths, viewer.login, "Claude through the Bridge MCP server") };
+}
+
+// src/explorations.ts
 var USE_CASES = new Set(EXPLORATION_USE_CASES.map((u) => u.value));
 var settingsOf = (config) => ({ base: baseBranchOf(config), packages: config.previews?.packages ?? [], apps: config.previews?.apps ?? {} });
 async function requireGitHub(ctx) {
@@ -6319,8 +8072,11 @@ async function startExploration(ctx, a) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   const gh = await ctx.github().catch(() => null);
+  const product = await resolveProduct(ctx, a.product);
+  const marks = productMarks(productsOf(config), product);
   const preview = {
     branch,
+    product: product.name,
     slug: slug2,
     base: s.base,
     title: explorationPrTitle(e),
@@ -6332,6 +8088,7 @@ async function startExploration(ctx, a) {
   const work = `Work on it: \`git fetch origin && git switch ${branch}\`. Token edits: bridge_propose_token_change with "branch": "${branch}". Requests: bridge_create_request with "exploration": "${branch}", then bridge_get_request with "branch": "${branch}". It is never merged as is: promote it (\`bridge explore promote ${slug2}\`) or close it.`;
   if (gh && ctx.canWriteRemote) {
     const r = await startExplorationOnGitHub(gh, e, s);
+    if (marks.labels.length) await gh.addLabels(r.pr, marks.labels);
     return {
       status: "started",
       ...preview,
@@ -6793,6 +8550,10 @@ async function getGuidelines(ctx, a) {
 }
 async function proposeTokenChange(ctx, a) {
   if (!a.edits?.length) throw new Error("Pass at least one edit.");
+  if (a.pr !== void 0 && a.branch) throw new Error("Pass pr (a branch in review) or branch (an exploration), not both.");
+  if (a.pr !== void 0) return addToBranch(ctx, { ...a, pr: a.pr });
+  const jira = parseJiraKey(a.jira);
+  const product = await resolveProduct(ctx, a.product);
   const target = a.branch ? await explorationContext(ctx, a.branch, { requireCheckout: !a.dryRun }) : null;
   if (target) ctx = target.ctx;
   const { config } = await ctx.config();
@@ -6807,7 +8568,8 @@ async function proposeTokenChange(ctx, a) {
   const imp = core.impact(before, after, changes);
   const tier = core.classify(changes, [], config);
   const summary2 = a.summary?.trim() || a.title;
-  const body = core.prBody({ summary: summary2, changes, contrast: delta2, impact: imp, tier, validationErrors: newErrors.length, tool: "Bridge MCP" });
+  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 = [
@@ -6827,7 +8589,7 @@ async function proposeTokenChange(ctx, a) {
   if (newErrors.length || newFailures.length) {
     return { status: "blocked", why: [newErrors.length ? `${newErrors.length} new validation error(s)` : "", newFailures.length ? `${newFailures.length} contrast pair(s) would fail` : ""].filter(Boolean).join(" and "), newErrors, ...report, hint: "Fix the edits (or add edits for the aliases they break). Bridge never opens a PR that breaks the gate." };
   }
-  let branch = target ? target.branch : `${config.governance.branchPrefix}${slugTitle}`;
+  let branch = target ? target.branch : branchWithJiraKey(`${config.governance.branchPrefix}${slugTitle}`, jira);
   const preview = { ...report, branch, files: files.map((f) => f.path), prBody: body };
   if (a.dryRun) return { status: "dry-run", ...preview, fileContents: files };
   if (target) {
@@ -6841,7 +8603,7 @@ Exploration ${target.branch}: not merged as is. Proposed through Bridge MCP (sou
   if (ctx.mode === "local") {
     if (!ctx.isGit) return { status: "preview", message: "Not a git repo: nothing written. Apply fileContents yourself.", ...preview, fileContents: files };
     const protectedBranches = [.../* @__PURE__ */ new Set([...protectedBranchesOf(config), baseBranchOf(config)])];
-    for (let i = 2; await branchExists(ctx.root, branch); i++) branch = `${config.governance.branchPrefix}${slugTitle}-${i}`;
+    for (let i = 2; await branchExists(ctx.root, branch); i++) branch = branchWithJiraKey(`${config.governance.branchPrefix}${slugTitle}-${i}`, jira);
     const base2 = await currentBranch(ctx.root);
     const message = `${tier.bump === "major" ? "feat(tokens)!" : "feat(tokens)"}: ${a.title}
 
@@ -6866,12 +8628,46 @@ Tier ${tier.tier}. Proposed through Bridge MCP (source: mcp).`;
 
 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 = `${config.governance.branchPrefix}${slugTitle}-${i}`;
+  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"] : []];
-  const pr = await gh.createPullRequest({ base, head: branch, title: `feat(tokens): ${a.title}`, body, draft: tier.tier >= 2 });
+  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);
-  return { status: "pr-opened", ...preview, branch, commit: commit.sha, pr: pr.number, url: pr.url, labels, draft: tier.tier >= 2 };
+  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) {
+  const n = branchNumber(a.pr);
+  const target = await addableBranch(ctx, n);
+  const at = await BridgeContext.create({ ...ctx.opts, repo: target.gh.fullName, ref: target.pr.headRef });
+  const { config } = await at.config();
+  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 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);
+  const tier = core.classify(changes, [], config);
+  const summary2 = a.summary?.trim() || a.title;
+  const report = { pr: n, branch: target.pr.headRef, tier: tier.tier, changes: changes.map((c) => ({ kind: c.kind, path: c.path, file: prefixPath(after, c.file), before: c.beforeCss, after: c.afterCss })), contrast: { moved: delta2.length, newFailures }, notes };
+  if (newErrors.length || newFailures.length) {
+    return { status: "blocked", why: [newErrors.length ? `${newErrors.length} new validation error(s)` : "", newFailures.length ? `${newFailures.length} contrast pair(s) would fail` : ""].filter(Boolean).join(" and "), newErrors, ...report, hint: "Fix the edits. Bridge never adds edits that break the gate." };
+  }
+  const paths = changes.map((c) => c.path);
+  const files = [
+    ...touched.map((f) => ({ path: prefixPath(after, f), content: after.files.get(f) })),
+    ...config.changesets ? [{ path: `${config.changesets.dir ?? ".changeset"}/bridge-${core.slugify(a.title)}-${n}-${Date.now().toString(36)}.md`, content: core.changeset(config.changesets.package, tier.bump, summary2) }] : []
+  ];
+  if (a.dryRun) return { status: "dry-run", ...report, files: files.map((f) => f.path) };
+  const message = `tokens: ${a.title}
+
+${paths.map((p) => `- ${p}`).join("\n")}
+
+Added with Claude through the Bridge MCP server.`;
+  const res = await target.gh.commitToBranch({ branch: target.pr.headRef, message, files });
+  await target.gh.createIssueComment(n, target.comment(paths)).catch(() => void 0);
+  return { status: "added", ...report, commit: res.sha, url: target.pr.url, said: `Added ${paths.length} edit${paths.length === 1 ? "" : "s"} to #${n}. Reviewers see ${paths.length === 1 ? "it" : "them"} now; GitHub may ask for approvals again.` };
 }
 async function listReviews(ctx, a) {
   const { config } = await ctx.config();
@@ -6967,7 +8763,7 @@ async function getReview(ctx, a) {
     impact: imp
   };
 }
-var sameLogin = (a, b) => a.trim().toLowerCase().replace(/^@/, "") === b.trim().toLowerCase().replace(/^@/, "");
+var sameLogin2 = (a, b) => a.trim().toLowerCase().replace(/^@/, "") === b.trim().toLowerCase().replace(/^@/, "");
 async function reviewRoles(gh, config, approvers) {
   const { owners, rights } = config.governance;
   const teams = await new TeamDirectory(gh).resolve(owners);
@@ -6975,7 +8771,7 @@ async function reviewRoles(gh, config, approvers) {
   const lists = expandOwners(entries, teams);
   const role = (k) => ({
     owners: entries[k].map((e) => entryLabel(e, teams)),
-    approvedBy: approvers.filter((a) => lists[k].some((x) => sameLogin(x, a)))
+    approvedBy: approvers.filter((a) => lists[k].some((x) => sameLogin2(x, a)))
   });
   const ship = shipPolicy(owners, rights, teams);
   const unreadable = unreadableTeams(teams);
@@ -6992,10 +8788,11 @@ async function reviewPr(ctx, a) {
   if (!ctx.canWriteRemote) throw new Error("Reviewing needs GITHUB_TOKEN. Without it Bridge is read-only.");
   if (!a.body.trim()) throw new Error("A review needs a body that says what to fix or why it is fine.");
   const event = { comment: "COMMENT", approve: "APPROVE", request_changes: "REQUEST_CHANGES" }[a.event];
-  const r = await gh.createReview(a.pr, { event, body: `${a.body.trim()}
+  const head = (await gh.getPullRequest(a.pr)).headSha;
+  const r = await reviewOnGitHub(gh, { number: a.pr, event, body: `${a.body.trim()}
 
-_Review drafted with Bridge MCP by an AI agent on behalf of the token owner._` });
-  return { pr: a.pr, event, id: r.id, state: r.state, note: event === "APPROVE" ? "Approval recorded under your GitHub account. A human still merges." : void 0 };
+_Review drafted with Bridge MCP by an AI agent on behalf of the token owner._`, headSha: head });
+  return { pr: a.pr, event, id: r.id, state: r.state, note: event === "APPROVE" ? "Approval recorded under your GitHub account. Merging is a separate step (bridge_merge_branch), only when the person asks." : void 0 };
 }
 async function scaffoldComponentOp(ctx, a) {
   const { config } = await ctx.config();
@@ -7022,7 +8819,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-XSBCZV4W.js")).runImpact;
+  const runImpact = run2 ?? (await import("./src-2YRRAUUM.js")).runImpact;
   const r = await runImpact({
     root: ctx.root,
     base: a.base ?? "main",
@@ -7416,8 +9213,8 @@ async function proposeBrand(ctx, a) {
   }
   const files = plan.files.map((f) => ({ path: f.path, content: f.content }));
   const prefix = config.governance.branchPrefix;
-  const stem = `${prefix}brand-${plan.slug}`;
-  let branch = stem;
+  const stem2 = `${prefix}brand-${plan.slug}`;
+  let branch = stem2;
   if (a.dryRun) return { status: "dry-run", ...report, branch, fileContents: files };
   const message = `feat(tokens): add the ${plan.name} brand
 
@@ -7426,7 +9223,7 @@ New brand "${plan.slug}", started from ${plan.from}. ${report.contrast.line} (${
 Tier 3. Proposed through Bridge MCP (source: mcp).`;
   if (ctx.mode === "local") {
     if (!ctx.isGit) return { status: "preview", message: "Not a git repo: nothing written. Apply fileContents yourself.", ...report, branch, fileContents: files };
-    for (let i = 2; await branchExists(ctx.root, branch); i++) branch = `${stem}-${i}`;
+    for (let i = 2; await branchExists(ctx.root, branch); i++) branch = `${stem2}-${i}`;
     const base2 = await currentBranch(ctx.root);
     const protectedBranches = [.../* @__PURE__ */ new Set([...protectedBranchesOf(config), baseBranchOf(config)])];
     const res = await commitToNewLocalBranch(ctx.root, { base: "HEAD", branch, message, files, protectedBranches, branchPrefix: prefix });
@@ -7442,7 +9239,7 @@ Tier 3. Proposed through Bridge MCP (source: mcp).`;
   if (!ctx.canWriteRemote) return { status: "preview", message: "Read-only: set GITHUB_TOKEN to open this as a pull request.", ...report, branch, fileContents: files };
   const gh = await ctx.github();
   const base = ctx.ref ?? baseBranchOf(config);
-  for (let i = 2; await gh.getBranchSha(branch).then(Boolean, () => false); i++) branch = `${stem}-${i}`;
+  for (let i = 2; await gh.getBranchSha(branch).then(Boolean, () => false); i++) branch = `${stem2}-${i}`;
   const commit = await gh.commitToNewBranch({ base, branch, message, files });
   const pr = await gh.createPullRequest({ base, head: branch, title: `feat(tokens): ${plan.title.charAt(0).toLowerCase()}${plan.title.slice(1)}`, body: report.prBody, draft: true });
   const labels = [.../* @__PURE__ */ new Set([...config.governance.labels, "tier: 3", "tokens"])];
@@ -7573,7 +9370,12 @@ async function createRequest(ctx, a) {
     ...a.exploration ? { exploration: toExplorationBranch(a.exploration) } : {}
   };
   const settings = config.integrations?.requests;
-  const issue = composeRequestIssue(req, { labels: settings?.labels ?? [], assignees: settings?.assignees ?? [] });
+  const product = await resolveProduct(ctx, a.product);
+  const marks = productMarks(productsOf(config), product);
+  const composed = composeRequestIssue(req, { labels: settings?.labels ?? [], assignees: settings?.assignees ?? [] });
+  const issue = marks.labels.length ? { ...composed, body: `${composed.body}
+
+${marks.line}`, labels: [...composed.labels, ...marks.labels] } : composed;
   if (a.dryRun) return { status: "dry-run", issue };
   const gh = await requireGitHub2(ctx);
   if (!ctx.canWriteRemote) throw new Error("Creating a request needs GITHUB_TOKEN (issues: write on this repository). Without it Bridge is read-only.");
@@ -7651,8 +9453,131 @@ async function writeDrafts(ctx, a) {
   };
 }
 
+// src/studio.ts
+var studio_exports = {};
+__export(studio_exports, {
+  figmaCoverage: () => figmaCoverage,
+  getSettings: () => getSettings,
+  saveDocs: () => saveDocs
+});
+var DOC_KEYS = ["summary", "preview", "whenToUse", "whenNotToUse", "dos", "donts", "accessibility", "contentGuidelines", "anatomy"];
+async function saveDocs(ctx, a) {
+  const { config } = await ctx.config();
+  if (!config.components) throw new Error("No components.dir in bridge.config.json: Bridge does not know where component docs live.");
+  const name = a.component.trim();
+  if (!/^[A-Z][A-Za-z0-9]*$/.test(name)) throw new Error(`"${a.component}" is not a component name. Use the exported name, like Button (bridge_list_components lists them).`);
+  const unknown = Object.keys(a.docs).filter((k) => !DOC_KEYS.includes(k));
+  if (unknown.length) throw new Error(`Unknown docs sections: ${unknown.join(", ")}. Use ${DOC_KEYS.join(", ")}.`);
+  const path = `${config.components.dir}/${name}/${name}${config.components.docsSuffix}`;
+  const jira = parseJiraKey(a.jira);
+  const product = await resolveProduct(ctx, a.product);
+  const next = (current) => {
+    let base = {};
+    if (current) {
+      try {
+        base = JSON.parse(current);
+      } catch {
+        throw new Error(`${path} is not valid JSON on that branch. Fix it there first.`);
+      }
+    }
+    const merged = { summary: "", whenToUse: [], whenNotToUse: [], dos: [], donts: [], accessibility: [], ...base, ...a.docs };
+    const issues = validateDocs(merged);
+    if (issues.length) throw new Error(`The docs are not ready: ${issues.map((i) => `${i.field}: ${i.message}`).join(" ")}`);
+    return docsFileText(cleanDocs(merged), current);
+  };
+  const gh = await ctx.github();
+  if (a.pr !== void 0) {
+    const n = branchNumber(a.pr);
+    if (!gh) throw new Error('No GitHub repo known: set "repo" in bridge.config.json or add an origin remote.');
+    const pr = await gh.getPullRequest(n);
+    if (pr.state !== "open") throw new Error(`#${n} is ${pr.state}: save the docs on a new branch instead (leave pr out).`);
+    const current = (await gh.getFile(path, pr.headRef))?.text ?? null;
+    if (current === null) throw new Error(`${path} is not on #${n}. Save the docs on a new branch instead (leave pr out), or check the component name.`);
+    const text2 = next(current);
+    if (a.dryRun) return { status: "dry-run", pr: n, path, content: text2 };
+    if (!ctx.canWriteRemote) throw new Error(`Saving docs on #${n} needs a GitHub token with ${RIGHTS.docs}. Set GITHUB_TOKEN where the Bridge MCP server runs, or save it in the Library edit mode.`);
+    const sha = await commitFileOnGitHub(gh.withBranchPrefix(void 0), { path, branch: pr.headRef, message: `docs(${name.toLowerCase()}): edit usage guidance with Claude (Bridge MCP)`, next });
+    return { status: sha ? "committed" : "unchanged", pr: n, path, commit: sha || null, said: sha ? `Saved the ${name} docs on #${n}. Reviewers see them now.` : "The docs on that branch already say this." };
+  }
+  const original = await ctx.source.read(path);
+  const text = next(original);
+  if (original === text) return { status: "unchanged", path, said: `The ${name} docs on main already say this.` };
+  const edit = { path, component: name, slug: name.toLowerCase(), before: original, after: text };
+  const marks = productMarks(productsOf(config), product);
+  const notes = [a.notes?.trim(), marks.line].filter(Boolean).join("\n\n");
+  if (a.dryRun || !gh || !ctx.canWriteRemote) {
+    return {
+      status: a.dryRun ? "dry-run" : "preview",
+      path,
+      content: text,
+      product: product.name,
+      ...a.dryRun ? {} : { said: `Nothing sent: saving docs for review needs a GitHub token with ${RIGHTS.docs}. Set GITHUB_TOKEN, or write the file yourself on a branch.` }
+    };
+  }
+  const r = await proposeDocsOnGitHub(gh.withBranchPrefix("docs/"), [edit], {
+    base: ctx.ref ?? baseBranchOf(config),
+    title: a.title,
+    notes,
+    jira,
+    origin: DOCS_MCP_ORIGIN,
+    extraLabels: marks.labels,
+    commitNote: "Proposed with Claude through the Bridge MCP server."
+  });
+  return { status: "sent-for-review", pr: r.number, url: r.url, title: r.title, path, product: product.name, said: `Sent the ${name} docs for review as #${r.number}. Docs only: one approval ships them.` };
+}
+async function getSettings(ctx) {
+  const { config } = await ctx.config();
+  const { owners, rights } = config.governance;
+  const override = config.governance.override ?? DEFAULT_OVERRIDE;
+  const gh = await ctx.github();
+  const teams = gh ? await new TeamDirectory(gh).resolve(owners).catch(() => void 0) : void 0;
+  const entries = approverEntries(owners, rights);
+  const ship = shipPolicy(owners, rights, teams);
+  const protection = gh ? await loadProtection(gh, baseBranchOf(config)).catch(() => null) : null;
+  const products = productsOf(config);
+  const unreadable = teams ? unreadableTeams(teams) : [];
+  return {
+    repo: config.repo ? `${config.repo.owner}/${config.repo.name}` : gh?.fullName ?? null,
+    main: baseBranchOf(config),
+    roles: {
+      designApproval: entries.design.map((e) => entryLabel(e, teams)),
+      techApproval: entries.tech.map((e) => entryLabel(e, teams)),
+      ship: ship ? whoCanShipSentence(ship) : "Anyone with write access can merge.",
+      ...unreadable.length ? { teamsNotRead: unreadable.map((t) => t.message) } : {}
+    },
+    ownerOverride: override.allowed.length ? { on: true, who: override.allowed.map((l) => `@${l}`), reason: override.requireReason ? `A reason of at least ${override.minReasonLength} characters, posted on the branch.` : "No reason required." } : { on: false, who: [], reason: "Nobody can merge without the approvals." },
+    protection: protection ? protectionSentence(protection) : "Not read (no GitHub repo known, or GitHub did not answer).",
+    products: products.map((p) => ({ key: p.key, name: p.name, default: p === defaultProduct(products) })),
+    previews: Object.entries(config.previews?.apps ?? {}).filter(([, t]) => Boolean(t)).map(([app]) => app),
+    visualImpact: config.visualImpact?.mode ?? "auto",
+    note: "Settings change in bridge.config.json through a reviewed branch, or in Studio Settings. Tokens and secrets are never shown."
+  };
+}
+async function figmaCoverage(ctx, a = {}) {
+  const text = await ctx.source.read(DEFAULT_COMPONENT_SPECS_FILE);
+  if (!text) return { components: [], summary: `No ${DEFAULT_COMPONENT_SPECS_FILE} in this repo: run \`npm run specs\` (or the DS Bridge Figma plugin) to record what is in Figma.` };
+  const file = parseComponentSpecs(text);
+  const s = coverageSummary(file);
+  const gh = await ctx.github();
+  const manifest = gh ? await gh.readFile(FIGMA_REFERENCES_MANIFEST, FIGMA_REFERENCES_BRANCH).catch(() => void 0) : void 0;
+  let references = null;
+  try {
+    const m = manifest ? JSON.parse(manifest) : null;
+    if (m?.components) references = { components: Object.keys(m.components).length, variants: Object.values(m.components).reduce((n, c) => n + Object.keys(c.variants ?? {}).length, 0), sha: m.sha };
+  } catch {
+    references = null;
+  }
+  const list = (file.coverage ?? []).filter((c) => !a.component || c.name.toLowerCase() === a.component.toLowerCase());
+  if (a.component && !list.length) throw new Error(`${a.component} is not in the coverage list. bridge_list_components lists the components.`);
+  return {
+    summary: `${s.inFigma} of ${s.visual} components are in Figma${s.drafted ? ` (${s.drafted} drafted with Claude)` : ""}; ${s.layout} layout helpers use auto layout.`,
+    components: list.map((c) => ({ name: c.name, inFigma: figmaCell(c)?.label ?? "Unknown", ...c.reason ? { why: c.reason } : {} })),
+    fidelity: references === null ? "No code images for the fidelity check yet (they live on the bridge-visual branch). The DS Bridge Figma plugin compares Figma with them." : `Code images of ${references.variants} variants (${references.components} components, commit ${references.sha.slice(0, 7)}) are ready for the fidelity check. The DS Bridge Figma plugin compares each Figma variant with them; the scores live in Figma.`
+  };
+}
+
 // src/server.ts
-var VERSION = true ? "0.3.2" : "dev";
+var VERSION = true ? "0.4.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) => {
@@ -7690,6 +9615,8 @@ function createServer(ctx) {
         "To undo a merged token change use bridge_plan_revert first (it shows conflicts with later changes), then bridge_propose_revert; never revert by hand-editing files.",
         'Component changes (new component, variant, prop, structure, visual, token binding) are requests: GitHub issues labeled component-change. bridge_list_requests finds them, bridge_get_request returns a brief to implement one in a pull request that says "Closes #n", bridge_create_request files a new one.',
         `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.',
         '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(" ")
     }
@@ -7824,7 +9751,10 @@ function createServer(ctx) {
         summary: z.string().optional().describe("Why: the problem and the intent, for the reviewers. Plain sentences, no em dash."),
         edits: z.array(EditArg).min(1),
         dryRun: z.boolean().optional().describe("Return the diff, tier, files and PR body without writing."),
-        branch: z.string().optional().describe("Exploration branch (explore/<slug>) to commit the edits to instead of opening a new pull request. GitHub: one commit on that branch. Local: written to the working tree, which must have that branch checked out. Never main.")
+        branch: z.string().optional().describe("Exploration branch (explore/<slug>) to commit the edits to instead of opening a new pull request. GitHub: one commit on that branch. Local: written to the working tree, which must have that branch checked out. Never main."),
+        pr: z.union([z.number().int().positive(), z.string().min(1)]).optional().describe('A branch already in review (12 or "#12") to add the edits to, as "Edit tokens in this branch" in Studio: one commit there and a comment for the reviewers. Its author or someone with write access; needs GITHUB_TOKEN.'),
+        jira: z.string().optional().describe("Jira key like DS-42, as in Studio's Create branch: first in the branch name and title so Jira links them."),
+        product: z.string().optional().describe("Product key or name (bridge_list_products) the change is for. Default: the product of the current folder or repo. Ask the person when it is not obvious.")
       },
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
     },
@@ -7892,7 +9822,7 @@ function createServer(ctx) {
     "bridge_review_pr",
     {
       title: "Review pull request",
-      description: "Post a review on a PR as the token owner: comment, approve or request changes. Needs GITHUB_TOKEN. Only do this when the user asked for it; never merge (Bridge cannot).",
+      description: "Post a review on a PR as the token owner: comment, approve or request changes, with a body. Kept for older prompts: bridge_review_branch does the same in designer words (an approval may have no text). Needs GITHUB_TOKEN. Only do this when the user asked for it; merging is a separate step (bridge_merge_branch), only when the person asks.",
       inputSchema: { pr: z.number().int().positive(), event: z.enum(["comment", "approve", "request_changes"]), body: z.string().min(1).describe("What to fix or why it is fine. Plain sentences.") },
       annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
     },
@@ -8064,6 +9994,7 @@ function createServer(ctx) {
         changes: z.array(z.object({ field: z.string().min(1).describe('A prop, variant axis, token or part: "size", "radius", "color.action.primary.bg".'), before: z.string().optional(), after: z.string().optional() })).optional().describe("What changes, from what to what."),
         figmaUrl: z.string().url().optional().describe("Link to the design in Figma, when there is one."),
         exploration: z.string().optional().describe("Exploration branch (explore/<slug>) to implement it on instead of a pull request to main. Adds the exploration label."),
+        product: z.string().optional().describe("Product key or name (bridge_list_products) it is for. Default: the product of the current folder or repo."),
         dryRun: z.boolean().optional().describe("Return the issue title, body and labels without creating it.")
       },
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
@@ -8143,6 +10074,7 @@ function createServer(ctx) {
         purpose: z.string().min(1).describe("What the team wants to learn, one or two plain sentences. No em dash."),
         useCase: z.enum(EXPLORATION_USE_CASES.map((u) => u.value)).optional().describe(EXPLORATION_USE_CASES.map((u) => `${u.value}: ${u.hint}`).join(" ")),
         experimental: z.array(z.string()).optional().describe('What is experimental, one line each: "color.action.primary.bg", "Button: pill radius".'),
+        product: z.string().optional().describe("Product key or name (bridge_list_products) it is tried in. Default: the product of the current folder or repo."),
         dryRun: z.boolean().optional().describe("Return the branch, note and pull request body without writing.")
       },
       annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true }
@@ -8159,6 +10091,233 @@ function createServer(ctx) {
     },
     run((a) => listExplorations(ctx, a))
   );
+  server.registerTool(
+    "bridge_promote_exploration",
+    {
+      title: "Promote an exploration to review",
+      description: "Promote an exploration (explore/<name>) to review, as in Studio: the draft becomes ready for review with its tier labels, the exploration label and note go, and the component requests it implements are linked so they close when it merges. Never merges. Needs GITHUB_TOKEN (contents and pull requests: write). Only when the person asked; dryRun shows what changes.",
+      inputSchema: { exploration: z.string().min(1).describe("Its name, explore/<name> branch or number (#42)."), dryRun: z.boolean().optional() },
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true }
+    },
+    run((a) => promoteExploration(ctx, { ref: a.exploration, dryRun: a.dryRun }))
+  );
+  server.registerTool(
+    "bridge_close_exploration",
+    {
+      title: "Close an exploration",
+      description: "Close an exploration without merging it, as in Studio. Its branch and previews stay on GitHub. Needs GITHUB_TOKEN (pull requests: write). Only when the person asked.",
+      inputSchema: { exploration: z.string().min(1).describe("Its name, explore/<name> branch or number (#42).") },
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    run((a) => closeExploration(ctx, { ref: a.exploration }))
+  );
+  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 };
+  server.registerTool(
+    "bridge_list_products",
+    {
+      title: "List products",
+      description: 'The products of this design system (bridge.config.json "products": name, repo or folder, preview link pattern, framework) and the one the current folder or repo belongs to, which tools that start work use when no product is given. Ask the person which product when it is not obvious.',
+      inputSchema: {},
+      annotations: RO
+    },
+    run(async () => listProducts(ctx))
+  );
+  server.registerTool(
+    "bridge_what_needs_me",
+    {
+      title: "What needs me",
+      description: 'The review queue, as Studio counts it (open branches, without running explorations and the release automation), each with its status in designer words, and first the ones where the person acts now: an approval they can give, their own branch blocked, ready for them to merge. Needs GITHUB_TOKEN to know who "me" is; without it, the queue only.',
+      inputSchema: { limit: z.number().int().min(1).max(50).optional().describe("Branches read (default 20, each costs a few GitHub reads).") },
+      annotations: READ
+    },
+    run((a) => whatNeedsMe(ctx, a))
+  );
+  server.registerTool(
+    "bridge_branch_status",
+    {
+      title: "Branch status",
+      description: "One branch in review as Studio shows it: its product, status (draft, in review, needs design or tech approval, blocked by tests, conflict, ready to merge, merged, closed), approvals, tests, how it stands against main, whether the person may merge it (same gate as the Merge button), and the next step. For the token diff and contrast, use bridge_get_review.",
+      inputSchema: { pr: Pr },
+      annotations: READ
+    },
+    run((a) => branchStatus(ctx, a))
+  );
+  server.registerTool(
+    "bridge_list_comments",
+    {
+      title: "List comments",
+      description: "The conversation on a branch and its line comment threads, with the ids to reply to (bridge_comment with replyTo).",
+      inputSchema: { pr: Pr },
+      annotations: READ
+    },
+    run((a) => listComments(ctx, a))
+  );
+  server.registerTool(
+    "bridge_try_branch",
+    {
+      title: "Try it in a product, share it",
+      description: 'Try a branch before it merges: the preview link of each product Vercel reported for it (the admin demo opens with the Bridge toolbar on, as "Try it in the product" in Studio), the other previews, and "Share with a product team": the install command a product team runs in a staging branch, or why there is none yet, with a ready-to-paste message. Never a guessed link. Writes nothing.',
+      inputSchema: { pr: Pr },
+      annotations: READ
+    },
+    run((a) => tryBranch(ctx, a))
+  );
+  server.registerTool(
+    "bridge_combine_branches",
+    {
+      title: "Try 2 to 4 branches together",
+      description: `Combined preview of 2 to 4 token branches, as "Try together" in Studio: each branch's own token edits on the latest main, the tokens two branches set differently (pick one per key with picks), and the links that open the combination (the admin demo with the Bridge toolbar, the library views). Branches that change code are refused. Writes nothing.`,
+      inputSchema: {
+        prs: z.array(Pr).min(2).max(4).describe("2 to 4 branch numbers."),
+        picks: z.record(z.string(), z.number().int().positive()).optional().describe('For each conflict key, the branch whose value to use: {"semantic/light.tokens.json#color.text.muted": 118}.')
+      },
+      annotations: READ
+    },
+    run((a) => combineBranches(ctx, a))
+  );
+  server.registerTool(
+    "bridge_get_settings",
+    {
+      title: "Get settings",
+      description: "What Studio Settings shows that is safe to read: who approves design and tech (GitHub teams named with their size), who may merge, the owner override (who, what reason), whether main is protected, the products, the preview apps and the visual impact mode. Never tokens or secrets.",
+      inputSchema: {},
+      annotations: READ
+    },
+    run(async () => getSettings(ctx))
+  );
+  server.registerTool(
+    "bridge_figma_coverage",
+    {
+      title: "Figma coverage",
+      description: "Which components are in Figma, in Studio's words (Yes, Drafted, Auto layout, Not yet with the reason), and whether code images exist for the fidelity check the DS Bridge Figma plugin runs (its scores live in Figma).",
+      inputSchema: { component: z.string().optional().describe("One component, e.g. Button.") },
+      annotations: READ
+    },
+    run((a) => figmaCoverage(ctx, a))
+  );
+  server.registerTool(
+    "bridge_send_for_review",
+    {
+      title: "Send for review",
+      description: 'Ask for review: a draft branch becomes ready for review, as "Mark as ready" in Studio. Its author only. Needs GITHUB_TOKEN (pull requests: write).',
+      inputSchema: { pr: Pr },
+      annotations: { ...WRITE, idempotentHint: true }
+    },
+    run((a) => sendForReview(ctx, a))
+  );
+  server.registerTool(
+    "bridge_back_to_draft",
+    {
+      title: "Back to draft",
+      description: "Take a branch out of review back to draft, as in Studio's More menu. Its author only. Needs GITHUB_TOKEN (pull requests: write).",
+      inputSchema: { pr: Pr },
+      annotations: { ...WRITE, idempotentHint: true }
+    },
+    run((a) => backToDraft(ctx, a))
+  );
+  server.registerTool(
+    "bridge_review_branch",
+    {
+      title: "Review a branch",
+      description: "Approve, request changes or comment on a branch, as the review box in Studio, on the version the person saw, under their GitHub account. Request changes and comment need a text that says what to change; an approval may have none. Only when the person asked. Needs GITHUB_TOKEN (pull requests: write).",
+      inputSchema: {
+        pr: Pr,
+        decision: z.enum(["approve", "request_changes", "comment"]),
+        body: z.string().optional().describe("What to change, or why it is fine. Plain sentences, no em dash.")
+      },
+      annotations: WRITE
+    },
+    run((a) => reviewBranch(ctx, a))
+  );
+  server.registerTool(
+    "bridge_ask_someone_else",
+    {
+      title: "Ask someone else to review",
+      description: 'Ask the other people who can give the missing approvals to review a branch, as "Ask someone else to review" in the Studio review queue, and take the person off its requested reviewers. Never the person or the author. Only when the person asked; dryRun says who would be asked. Needs GITHUB_TOKEN (pull requests: write).',
+      inputSchema: { pr: Pr, dryRun: z.boolean().optional() },
+      annotations: { ...WRITE, idempotentHint: true }
+    },
+    run((a) => askSomeoneElse(ctx, a))
+  );
+  server.registerTool(
+    "bridge_comment",
+    {
+      title: "Comment on a branch",
+      description: "Post a comment on a branch, or reply in the thread of a line comment (replyTo: its id from bridge_list_comments). Needs GITHUB_TOKEN (pull requests: write).",
+      inputSchema: { pr: Pr, body: z.string().min(1).describe("Plain sentences, no em dash."), replyTo: z.number().int().positive().optional().describe("Line comment thread to reply in.") },
+      annotations: WRITE
+    },
+    run((a) => commentOnBranch(ctx, a))
+  );
+  server.registerTool(
+    "bridge_merge_branch",
+    {
+      title: "Merge a branch",
+      description: "Merge a branch into main through the same gate as Studio's Merge button: tests pass, the approvals its tier needs, no changes requested, no conflict, not a draft or an exploration, and the person holds the right to ship (governance.rights). When it is blocked, the error says by what. Owner override: pass overrideReason when only approvals are missing and the person is in governance.override.allowed; the reason is posted on the branch first. Only when the person explicitly asked to merge; dryRun checks without merging. Needs GITHUB_TOKEN (contents and pull requests: write); GitHub's own branch rules still apply.",
+      inputSchema: {
+        pr: Pr,
+        overrideReason: z.string().optional().describe("Owner override only: why it merges without the missing approvals (at least the configured length). Posted on the branch."),
+        dryRun: z.boolean().optional().describe("Check the gate without merging.")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
+    },
+    run((a) => mergeBranch(ctx, a))
+  );
+  server.registerTool(
+    "bridge_close_branch",
+    {
+      title: "Close a branch",
+      description: "Close a branch without merging it, as in Studio's More menu. Its work stays on GitHub and it can be reopened. Explorations close with bridge_close_exploration. Only when the person asked. Needs GITHUB_TOKEN (pull requests: write).",
+      inputSchema: { pr: Pr },
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true }
+    },
+    run((a) => closeBranch(ctx, a))
+  );
+  server.registerTool(
+    "bridge_reopen_branch",
+    {
+      title: "Reopen a branch",
+      description: "Reopen a closed branch, with Studio's rule: its author or an owner with write access, and only while its work is still on GitHub. Needs GITHUB_TOKEN (pull requests: write).",
+      inputSchema: { pr: Pr },
+      annotations: { ...WRITE, idempotentHint: true }
+    },
+    run((a) => reopenBranch(ctx, a))
+  );
+  server.registerTool(
+    "bridge_update_from_main",
+    {
+      title: "Update from main",
+      description: `Bring the latest main into a branch, as "Update from main" in Studio. Nothing conflicts: GitHub updates it. Only token files conflict: the tokens changed on both sides come back with keys; pass choices ("mine" keeps the branch value, "theirs" uses main's; tokens with a default keep the branch value) and Bridge commits the resolution. Code conflicts stay with a developer on GitHub. dryRun shows what would happen. Needs GITHUB_TOKEN (contents and pull requests: write).`,
+      inputSchema: {
+        pr: Pr,
+        choices: z.record(z.string(), z.enum(["mine", "theirs"])).optional().describe('Per conflict key from a dry run: "mine" or "theirs".'),
+        dryRun: z.boolean().optional()
+      },
+      annotations: WRITE
+    },
+    run((a) => updateFromMain(ctx, a))
+  );
+  server.registerTool(
+    "bridge_save_docs",
+    {
+      title: "Save component docs",
+      description: `Save a component's usage guidance (docs.json sections: summary, whenToUse, whenNotToUse, dos, donts, accessibility, contentGuidelines, anatomy, preview) the way the Library edit mode does: merged into the docs on the branch, cleaned and checked (a summary, no empty items, no em dash). Without pr: a new branch sent for review (docs only: one approval, patch release note), with an optional Jira key and product. With pr: one commit on that open branch. dryRun returns the file. Needs GITHUB_TOKEN (contents and pull requests: write). Prose you drafted carries "draftedBy": "claude" and "needsReview": true so a reviewer accepts it in Studio.`,
+      inputSchema: {
+        component: z.string().min(1).describe("Component name, e.g. Button."),
+        docs: z.record(z.string(), z.unknown()).describe('The sections to set, in docs.json shapes: summary a string; whenToUse, whenNotToUse, accessibility, contentGuidelines lists of strings; dos and donts lists of {"title","text"}.'),
+        pr: Pr.optional().describe("An open branch to save the docs on, instead of a new one."),
+        title: z.string().optional().describe('Title of the new branch. Default: "docs(<component>): usage guidance for <Component>".'),
+        notes: z.string().optional().describe("Why, for the reviewers."),
+        jira: z.string().optional().describe("Jira key like DS-42: first in the branch name and title so Jira links them."),
+        product: z.string().optional().describe("Product key or name (bridge_list_products). Default: the product of the current folder or repo."),
+        dryRun: z.boolean().optional()
+      },
+      annotations: WRITE
+    },
+    run((a) => saveDocs(ctx, a))
+  );
   server.registerResource("resolved-tokens", "bridge://tokens/resolved", { title: "Resolved tokens", description: "Every token resolved in the default mode, plus only the values that differ in each other mode combination.", mimeType: "application/json" }, async (uri) => {
     const set = await ctx.tokens();
     const def = set.defaultCombo;
@@ -8191,8 +10350,8 @@ function createServer(ctx) {
     new ResourceTemplate("bridge://components/{name}", {
       list: async () => {
         const { config } = await ctx.config();
-        const names = await listComponentNames(ctx.source, config);
-        return { resources: names.map((n) => ({ uri: `bridge://components/${n.name}`, name: n.name, mimeType: "application/json" })) };
+        const names2 = await listComponentNames(ctx.source, config);
+        return { resources: names2.map((n) => ({ uri: `bridge://components/${n.name}`, name: n.name, mimeType: "application/json" })) };
       },
       complete: {
         name: async (value) => {
@@ -8372,12 +10531,14 @@ export {
   GitHubSource,
   BridgeContext,
   auditSnippet,
+  branches_exports,
   explorations_exports,
   ops_exports,
   history_exports,
   brand_exports,
   requests_exports,
   drafts_exports,
+  studio_exports,
   VERSION,
   createServer,
   serveStdio,