@bridge-ds/cli 0.11.1 → 0.12.0

package/dist/index.js

@@ -13,8 +13,9 @@ var FINDING_CATEGORIES = ["color", "spacing", "size", "radius", "border-width",
 var ALIAS_RE = /^\{([^{}]+)\}$/;
 var isAlias = (v) => typeof v === "string" && ALIAS_RE.test(v);
 var aliasTarget = (v) => ALIAS_RE.exec(v)?.[1] ?? v;
-function hexToRgba(hex) {
-  const m = /^#?([0-9a-f]{3,8})$/i.exec(hex.trim());
+var clamp01 = (n) => Math.min(1, Math.max(0, n));
+function hexToRgba(hex2) {
+  const m = /^#?([0-9a-f]{3,8})$/i.exec(hex2.trim());
   if (!m) return void 0;
   let h = m[1];
   if (h.length === 3 || h.length === 4) h = [...h].map((c) => c + c).join("");
@@ -22,6 +23,65 @@ function hexToRgba(hex) {
   const n = (idx) => parseInt(h.slice(idx, idx + 2), 16) / 255;
   return { r: n(0), g: n(2), b: n(4), a: h.length === 8 ? n(6) : 1 };
 }
+var to255 = (n) => Math.round(clamp01(n) * 255);
+var rgbaToHex = (c) => "#" + [c.r, c.g, c.b].map((x) => to255(x).toString(16).padStart(2, "0")).join("");
+function parseColor(value) {
+  if (typeof value === "string") return isAlias(value) ? void 0 : hexToRgba(value);
+  if (!value || typeof value !== "object") return void 0;
+  const v = value;
+  const alpha = typeof v.alpha === "number" ? v.alpha : 1;
+  if (v.colorSpace === "srgb" && Array.isArray(v.components) && v.components.length === 3) {
+    const [r, g, b] = v.components;
+    if ([r, g, b].every((x) => typeof x === "number")) return { r, g, b, a: alpha };
+  }
+  if (typeof v.hex === "string") {
+    const c = hexToRgba(v.hex);
+    if (c) return { ...c, a: alpha };
+  }
+  return void 0;
+}
+function colorsEqual(a, b) {
+  return rgbaToHex(a) === rgbaToHex(b) && Math.abs(a.a - b.a) < 2e-3;
+}
+function parseDimension(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const v = value;
+    if (typeof v.value === "number" && typeof v.unit === "string") return { value: v.value, unit: v.unit };
+  }
+  if (typeof value === "string") {
+    const m = /^(-?\d+(?:\.\d+)?)(px|rem)$/.exec(value.trim());
+    if (m) return { value: Number(m[1]), unit: m[2] };
+  }
+  if (typeof value === "number") return { value, unit: "px" };
+  return void 0;
+}
+var numbersEqual = (a, b) => Math.abs(a - b) < 1e-4;
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a === "number" && typeof b === "number") return numbersEqual(a, b);
+  if (typeof a !== typeof b || !a || !b || typeof a !== "object") return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((v, idx) => deepEqual(v, b[idx]));
+  const ka = Object.keys(a).filter((k) => a[k] !== void 0);
+  const kb = Object.keys(b).filter((k) => b[k] !== void 0);
+  if (ka.length !== kb.length) return false;
+  return ka.every((k) => deepEqual(a[k], b[k]));
+}
+function valuesEqual(type, a, b) {
+  if (a === void 0 || b === void 0) return a === b;
+  if (isAlias(a) || isAlias(b)) return isAlias(a) && isAlias(b) && aliasTarget(a) === aliasTarget(b);
+  if (type === "color") {
+    const ca = parseColor(a);
+    const cb = parseColor(b);
+    if (ca && cb) return colorsEqual(ca, cb);
+  }
+  if (type === "dimension") {
+    const da = parseDimension(a);
+    const db = parseDimension(b);
+    if (da && db) return da.unit === db.unit && numbersEqual(da.value, db.value);
+  }
+  return deepEqual(a, b);
+}
 
 // ../core/src/audit/color.ts
 var NAMED_COLORS = {
@@ -1119,9 +1179,9 @@ var DesignSystemIndex = class {
         return generic ? this.make(generic, 1, 0.3) : void 0;
       }
       case "shadow": {
-        const norm4 = (s) => s.replace(/\s+/g, " ").replace(/\s*,\s*/g, ", ").trim().toLowerCase();
+        const norm6 = (s) => s.replace(/\s+/g, " ").replace(/\s*,\s*/g, ", ").trim().toLowerCase();
         const cands = this.entries(["shadow"]);
-        const exact = cands.find((e) => norm4(e.css) === norm4(value));
+        const exact = cands.find((e) => norm6(e.css) === norm6(value));
         if (exact) return this.make(exact, 0, 1);
         const t = shadowNums(value);
         const scored = cands.map((e) => {
@@ -1572,16 +1632,16 @@ function applyAllowlist(entries, findings, components) {
   return { findings: keep(findings), components: keep(components), ignored, used };
 }
 function parseAllowlist(json) {
-  const fail = (msg) => {
+  const fail2 = (msg) => {
     throw new Error(`allowlist: ${msg}`);
   };
-  if (!json || typeof json !== "object" || !Array.isArray(json.entries)) fail('expected { "entries": [...] }');
+  if (!json || typeof json !== "object" || !Array.isArray(json.entries)) fail2('expected { "entries": [...] }');
   return json.entries.map((e, i) => {
     const x = e;
-    if (typeof x.file !== "string" || !x.file) fail(`entry ${i} needs "file"`);
-    if (typeof x.line !== "number" || !Number.isInteger(x.line) || x.line < 1) fail(`entry ${i} (${x.file}) needs a "line" number`);
-    if (typeof x.reason !== "string" || !x.reason.trim()) fail(`entry ${i} (${x.file}:${x.line}) needs a "reason"`);
-    if (x.what !== void 0 && typeof x.what !== "string") fail(`entry ${i} (${x.file}:${x.line}): "what" must be a string`);
+    if (typeof x.file !== "string" || !x.file) fail2(`entry ${i} needs "file"`);
+    if (typeof x.line !== "number" || !Number.isInteger(x.line) || x.line < 1) fail2(`entry ${i} (${x.file}) needs a "line" number`);
+    if (typeof x.reason !== "string" || !x.reason.trim()) fail2(`entry ${i} (${x.file}:${x.line}) needs a "reason"`);
+    if (x.what !== void 0 && typeof x.what !== "string") fail2(`entry ${i} (${x.file}:${x.line}): "what" must be a string`);
     return { file: x.file, line: x.line, ...x.what !== void 0 ? { what: x.what } : {}, reason: x.reason.trim() };
   });
 }
@@ -2176,8 +2236,8 @@ function parseOwnerEntry(raw) {
 var teamKey = (org, slug) => `@${org.toLowerCase()}/${slug.toLowerCase()}`;
 function ownerEntryProblems(raw) {
   if (raw === void 0) return [];
-  const isObj3 = (x) => Boolean(x) && typeof x === "object" && !Array.isArray(x);
-  if (!isObj3(raw)) return ['"governance.owners" must be { "design": [people or teams], "tech": [people or teams] }'];
+  const isObj4 = (x) => Boolean(x) && typeof x === "object" && !Array.isArray(x);
+  if (!isObj4(raw)) return ['"governance.owners" must be { "design": [people or teams], "tech": [people or teams] }'];
   const out = [];
   for (const [k, v] of Object.entries(raw)) {
     if (k !== "design" && k !== "tech") {
@@ -2220,6 +2280,31 @@ function teamsIn(owners) {
   return [...out.values()];
 }
 var norm = (x) => x.trim().toLowerCase().replace(/^@/, "");
+function expandEntries(entries, teams) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (x) => {
+    const k = norm(x);
+    if (k && !seen.has(k)) {
+      seen.add(k);
+      out.push(x.replace(/^@(?=[^/]+$)/, ""));
+    }
+  };
+  for (const raw of entries) {
+    const e = parseOwnerEntry(raw);
+    if (!e) continue;
+    if (e.kind === "person") add(e.login);
+    else {
+      const state = teams?.[teamKey(e.org, e.slug)];
+      if (state?.status === "ok") state.members.forEach(add);
+      else add(teamKey(e.org, e.slug));
+    }
+  }
+  return out;
+}
+function expandOwners(owners, teams) {
+  return { design: expandEntries(owners.design, teams), tech: expandEntries(owners.tech, teams) };
+}
 var people = (n) => `${n} ${n === 1 ? "person" : "people"}`;
 function entryLabel(raw, teams) {
   const e = parseOwnerEntry(raw);
@@ -2229,6 +2314,9 @@ function entryLabel(raw, teams) {
   const name = `@${e.org}/${e.slug}`;
   return state?.status === "ok" ? `${name} (${people(state.members.length)})` : name;
 }
+function unreadableTeams(teams) {
+  return Object.values(teams ?? {}).filter((t) => t.status === "unreadable");
+}
 var TeamDirectory = class {
   constructor(reader, opts = {}) {
     this.reader = reader;
@@ -2351,6 +2439,8 @@ var TeamDirectory = class {
 var OWNER_GROUPS = ["design", "tech"];
 var RIGHTS = ["approveDesign", "approveTech", "ship"];
 var DEFAULT_RIGHTS = { approveDesign: ["design"], approveTech: ["tech"], ship: ["tech"] };
+var norm2 = (x) => x.trim().toLowerCase().replace(/^@/, "");
+var uniq = (xs) => [...new Set(xs)];
 function normalizeRights(input) {
   const pick = (r) => {
     const v = input?.[r];
@@ -2370,6 +2460,43 @@ function rightsProblems(raw) {
   }
   return out;
 }
+function holdersOf(right, owners, rights) {
+  const groups = (rights ?? DEFAULT_RIGHTS)[right];
+  return uniq(groups.flatMap((g) => owners[g] ?? []));
+}
+function approverLists(owners, rights, teams) {
+  const entries = approverEntries(owners, rights);
+  return teams === void 0 ? entries : expandOwners(entries, teams);
+}
+function approverEntries(owners, rights) {
+  if (!rights) return { design: [...owners.design], tech: [...owners.tech] };
+  return { design: holdersOf("approveDesign", owners, rights), tech: holdersOf("approveTech", owners, rights) };
+}
+function soloApprover(owners) {
+  const d = [...new Set(owners.design.map(norm2))];
+  const t = [...new Set(owners.tech.map(norm2))];
+  if (d.length !== 1 || t.length !== 1 || d[0] !== t[0] || !d[0] || d[0].includes("/")) return null;
+  return d[0];
+}
+function unreadableShipTeams(policy) {
+  if (!policy?.teams) return [];
+  const keys = new Set((policy.entries ?? []).map((e) => e.trim().toLowerCase().replace(/^@?/, "@")));
+  return unreadableTeams(policy.teams).filter((t) => keys.has(t.key));
+}
+function canShip(login, policy) {
+  if (!policy) return true;
+  if (!login || login.includes("/")) return false;
+  return policy.logins.map(norm2).includes(norm2(login));
+}
+function groupsPhrase(groups) {
+  const g = OWNER_GROUPS.filter((x) => groups.includes(x));
+  if (g.length === 1) return `the ${g[0]} owner`;
+  return `a ${g.join(" or ")} owner`;
+}
+function whoCanShipSentence(policy) {
+  const names = (policy.entries ?? policy.logins).map((l) => entryLabel(l, policy.teams)).join(", ");
+  return `Only ${groupsPhrase(policy.groups)} can merge this${names ? ` (${names})` : ""}.`;
+}
 function visualImpactProblems(raw) {
   if (raw === void 0) return [];
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return ['"visualImpact" must be { "mode": "auto" | "on-demand" }'];
@@ -2740,6 +2867,116 @@ function loadConfig(source) {
 }
 var tokensPath = (config, rel = "") => [config.tokens.root === "." ? "" : config.tokens.root, rel].filter(Boolean).join("/");
 
+// ../core/src/scopes.ts
+var has = (segments, ...names) => names.some((n) => segments.includes(n));
+function defaultScopes(path, type, tier) {
+  const s = path.split(".");
+  switch (type) {
+    case "color":
+      if (tier === "primitive" || tier === "brand" && s[0] === "palette") return [];
+      if (has(s, "text")) return ["TEXT_FILL"];
+      if (has(s, "border", "ring", "outline")) return ["STROKE_COLOR"];
+      if (has(s, "bg", "surface", "background")) return ["FRAME_FILL", "SHAPE_FILL"];
+      if (has(s, "shadow")) return ["EFFECT_COLOR"];
+      return ["FRAME_FILL", "SHAPE_FILL", "TEXT_FILL", "STROKE_COLOR"];
+    case "dimension":
+      if (has(s, "radius")) return ["CORNER_RADIUS"];
+      if (has(s, "border", "width", "stroke")) return ["STROKE_FLOAT"];
+      if (has(s, "space", "spacing", "gap")) return ["GAP", "WIDTH_HEIGHT"];
+      if (has(s, "size") && has(s, "font")) return ["FONT_SIZE"];
+      if (has(s, "letter-spacing")) return ["LETTER_SPACING"];
+      return ["WIDTH_HEIGHT", "GAP"];
+    case "fontWeight":
+      return ["FONT_WEIGHT"];
+    case "fontFamily":
+      return ["FONT_FAMILY"];
+    case "number":
+      if (has(s, "line-height", "lineHeight")) return ["LINE_HEIGHT"];
+      if (has(s, "opacity")) return ["OPACITY"];
+      return ["WIDTH_HEIGHT", "GAP"];
+    case "string":
+      return ["TEXT_CONTENT"];
+    default:
+      return [];
+  }
+}
+var sameScopes = (a, b) => {
+  const sa = [...new Set(a)].sort();
+  const sb = [...new Set(b)].sort();
+  return sa.length === sb.length && sa.every((x, i) => x === sb[i]);
+};
+var effectiveScopes = (t) => t.scopes ?? defaultScopes(t.path, t.type, t.tier);
+
+// ../core/src/diff-engine.ts
+var normDesc = (d) => (d ?? "").trim();
+function fieldChanges(a, b) {
+  const out = [];
+  if (a.path !== b.path) out.push({ field: "path", before: a.path, after: b.path });
+  if (a.type !== b.type) out.push({ field: "type", before: a.type, after: b.type });
+  const modes = [.../* @__PURE__ */ new Set([...Object.keys(a.values), ...Object.keys(b.values)])];
+  for (const mode2 of modes) {
+    if (!valuesEqual(b.type, a.values[mode2], b.values[mode2])) out.push({ field: "value", mode: mode2, before: a.values[mode2], after: b.values[mode2] });
+  }
+  if (normDesc(a.description) !== normDesc(b.description)) out.push({ field: "description", before: a.description, after: b.description });
+  const sa = effectiveScopes(a);
+  const sb = effectiveScopes(b);
+  if (!sameScopes(sa, sb)) out.push({ field: "scopes", before: sa, after: sb });
+  return out;
+}
+
+// ../core/src/risk.ts
+var RISK_LABELS = {
+  1: "Tier 1: low risk, one code owner",
+  2: "Tier 2: medium risk, design review then design + tech approval",
+  3: "Tier 3: token change, needs design + tech approval"
+};
+var BUMP_RANK = { patch: 0, minor: 1, major: 2 };
+var LOW = [/\.md$/, /^docs\//, /\.stories\.tsx?$/, /\.docs\.json$/, /\.test\.tsx?$/, /^\.changeset\//];
+var isSummary = (c) => "kind" in c;
+function summarizeTokenChange(c) {
+  if (isSummary(c)) return c;
+  const path = (c.target ?? c.current).path;
+  if (!c.target) return { kind: "removed", path };
+  if (!c.current) return { kind: "added", path };
+  if (c.current.path !== c.target.path) return { kind: "renamed", path };
+  const fields = fieldChanges(c.current, c.target);
+  return { kind: "changed", path, descriptionOnly: fields.length > 0 && fields.every((f) => f.field === "description") };
+}
+function tokenBump(changes) {
+  let bump;
+  for (const c of changes.map(summarizeTokenChange)) {
+    const b = c.kind === "removed" || c.kind === "renamed" ? "major" : c.kind === "changed" && c.descriptionOnly ? "patch" : "minor";
+    if (!bump || BUMP_RANK[b] > BUMP_RANK[bump]) bump = b;
+  }
+  return bump;
+}
+function isGuardrail(path, config) {
+  const list2 = config ? [...config.governance.guardrails, CONFIG_FILE, ...config.contrast ? [config.contrast.path] : []] : DEFAULT_GOVERNANCE.guardrails;
+  return list2.some((g) => g.endsWith("/") ? path.startsWith(g) : path === g) || path.startsWith(".github/") || path.endsWith("/contrast.checks.json") || path === "contrast.checks.json";
+}
+function classifyRisk(input) {
+  const reasons = [];
+  const tokenChanges = (input.tokenChanges ?? []).map(summarizeTokenChange);
+  for (const c of tokenChanges) {
+    if (c.kind === "changed" && c.descriptionOnly) reasons.push({ tier: 1, text: `Token description changed: ${c.path}` });
+    else reasons.push({ tier: 3, text: `Token ${c.kind}: ${c.path}` });
+  }
+  const bump = tokenBump(tokenChanges);
+  const componentsDir = input.config?.components?.dir;
+  for (const f of input.files ?? []) {
+    const p = f.path.replace(/^\/+/, "");
+    if (p.endsWith(".tokens.json")) {
+      if (!input.tokenChanges) reasons.push({ tier: 3, text: `Token file ${f.status ?? "changed"}: ${p}` });
+    } else if (isGuardrail(p, input.config)) reasons.push({ tier: 3, text: `Guardrail file changed: ${p}` });
+    else if (LOW.some((r) => r.test(p))) reasons.push({ tier: 1, text: `Docs, story or test: ${p}` });
+    else if (componentsDir && p.startsWith(`${componentsDir}/`)) reasons.push({ tier: 2, text: `Component source ${f.status ?? "changed"}: ${p}` });
+    else reasons.push({ tier: 2, text: `Source file changed: ${p}` });
+  }
+  reasons.sort((a, b) => b.tier - a.tier);
+  const tier = reasons[0]?.tier ?? 1;
+  return { tier, label: RISK_LABELS[tier], reasons: reasons.map((r) => r.text), bump };
+}
+
 // ../core/src/node/git-local.ts
 import { execFile } from "node:child_process";
 
@@ -2843,6 +3080,198 @@ function diffLayered(before, after) {
   for (const d of added) changes.push({ kind: "added", path: d.path, file: d.file, ...d.type ? { type: d.type } : {}, fields: [], after: d.value, afterCss: css(after, d), ...d.description ? { descriptionAfter: d.description } : {}, ...tierOf(after, d.file) });
   return changes.sort((x, y) => x.path.localeCompare(y.path) || x.file.localeCompare(y.file));
 }
+var toChangeSummary = (c) => ({
+  kind: c.kind,
+  path: c.path,
+  ...c.kind === "changed" ? { descriptionOnly: c.fields.length > 0 && c.fields.every((f) => f === "description") } : {}
+});
+function classifyLayered(changes, otherFiles = [], config) {
+  const r = classifyRisk({ tokenChanges: changes.map(toChangeSummary), files: otherFiles.map((path) => ({ path })), config });
+  return { tier: r.tier, bump: r.bump ?? "patch", reasons: r.reasons.length ? r.reasons : ["No token or guardrail change"], label: r.label };
+}
+
+// ../core/src/history.ts
+var BULK_LIMIT = 60;
+var UNRELEASED = "Unreleased";
+var SUBJECT_PR = [/^Merge pull request #(\d+)/, /\(#(\d+)\)\s*$/];
+function prNumberFromSubject(subject) {
+  for (const re of SUBJECT_PR) {
+    const m = re.exec(subject);
+    if (m) return Number(m[1]);
+  }
+  return void 0;
+}
+function parseChangesetText(path, text) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(text);
+  if (!m) return null;
+  const bumps = [...m[1].matchAll(/["']?([^"'\s:]+)["']?\s*:\s*(major|minor|patch)/g)].map((x) => ({ pkg: x[1], bump: x[2] }));
+  const order = ["major", "minor", "patch"];
+  const bump = order.find((b) => bumps.some((x) => x.bump === b));
+  const summary = m[2].trim().split(/\r?\n\r?\n/)[0].replace(/\s+/g, " ").trim();
+  return { path, ...bump ? { bump } : {}, packages: bumps.map((b) => b.pkg), summary };
+}
+function firstParagraph(text) {
+  if (!text) return "";
+  const cleaned = text.replace(/<!--[\s\S]*?-->/g, "");
+  for (const para of cleaned.split(/\r?\n\s*\r?\n/)) {
+    const lines = para.split(/\r?\n/).filter((l) => l.trim() && !/^\s*#{1,6}\s/.test(l) && !/^\s*[-*]\s*\[[ xX]\]/.test(l) && !/^\s*(Co-Authored-By|Claude-Session|Signed-off-by):/i.test(l));
+    const s = lines.join(" ").replace(/\s+/g, " ").trim();
+    if (s && !/^\|/.test(s)) return s.length > 400 ? `${s.slice(0, 397)}...` : s;
+  }
+  return "";
+}
+function countChanges(changes) {
+  const c = { added: 0, changed: 0, removed: 0, renamed: 0, total: changes.length };
+  for (const x of changes) c[x.kind]++;
+  return c;
+}
+var shortSha = (sha) => sha.slice(0, 7);
+function titleOf(commit) {
+  if (commit.pr?.title) return commit.pr.title;
+  if (/^Merge pull request #\d+/.test(commit.subject)) {
+    const first = (commit.body ?? "").split(/\r?\n/).find((l) => l.trim());
+    if (first) return first.trim();
+  }
+  return commit.subject;
+}
+function buildHistoryEntry(input) {
+  const { config, commit } = input;
+  const beforeSet = new LayeredTokenSet(config, input.before);
+  const afterSet = new LayeredTokenSet(config, input.after);
+  const changes = diffLayered(beforeSet, afterSet);
+  if (!changes.length) return null;
+  const tier = classifyLayered(changes, [], config);
+  const changesets = (input.changesets ?? []).map((c) => parseChangesetText(c.path, c.text)).filter((c) => c !== null);
+  const pkg = config.changesets?.package;
+  const relevant = changesets.filter((c) => !pkg || !c.packages.length || c.packages.includes(pkg));
+  const title = titleOf(commit);
+  const why = relevant.map((c) => c.summary).find(Boolean) || firstParagraph(commit.pr?.body) || firstParagraph(commit.body) || title;
+  const prNumber = commit.pr?.number ?? prNumberFromSubject(commit.subject);
+  const pr = commit.pr ?? (prNumber ? { number: prNumber, title, ...config.repo ? { url: `https://github.com/${config.repo.owner}/${config.repo.name}/pull/${prNumber}` } : {} } : void 0);
+  const changesetBump = relevant.map((c) => c.bump).find((b) => b === "major");
+  const bump = changesetBump ?? tier.bump;
+  return {
+    id: pr ? `pr-${pr.number}` : shortSha(commit.sha),
+    sha: commit.sha,
+    ...commit.parents[0] ? { baseSha: commit.parents[0] } : {},
+    date: commit.date,
+    author: commit.pr?.author ?? commit.author,
+    title,
+    why,
+    ...pr ? { pr } : {},
+    changes,
+    counts: countChanges(changes),
+    tier: tier.tier,
+    bump,
+    breaking: bump === "major",
+    reasons: tier.reasons,
+    changesets: relevant,
+    ...changes.length > BULK_LIMIT ? { bulk: true } : {},
+    ...input.demo ? { demo: true } : {}
+  };
+}
+async function collectHistory(config, backend, opts) {
+  const root = config.tokens.root.replace(/\/$/, "");
+  const commits = await backend.listCommits({ ref: opts.ref, paths: [root === "." ? "" : root].filter(Boolean), limit: opts.limit ?? 40 });
+  const seen = /* @__PURE__ */ new Set();
+  const picked = [];
+  for (const c of commits) {
+    const n = c.pr?.number;
+    if (n !== void 0) {
+      if (seen.has(n)) continue;
+      seen.add(n);
+    }
+    picked.push(c);
+  }
+  const entries = [];
+  let done = 0;
+  for (const c of picked) {
+    const parent = c.parents[0];
+    const [before, after] = await Promise.all([parent ? backend.tokenFiles(parent) : Promise.resolve(/* @__PURE__ */ new Map()), backend.tokenFiles(c.sha)]);
+    let changesets = [];
+    if (backend.changesetPaths && backend.readFile && config.changesets) {
+      const [was, now] = await Promise.all([parent ? backend.changesetPaths(parent) : Promise.resolve([]), backend.changesetPaths(c.sha)]);
+      const added = now.filter((p) => !was.includes(p) && p.endsWith(".md") && !/README\.md$/i.test(p));
+      changesets = (await Promise.all(added.map(async (p) => ({ path: p, text: await backend.readFile(c.sha, p) ?? "" })))).filter((x) => x.text);
+    }
+    const e = buildHistoryEntry({ config, commit: c, before, after, changesets });
+    if (e) entries.push(e);
+    opts.onProgress?.(++done, picked.length);
+  }
+  return entries;
+}
+function parseChangelog(text) {
+  const out = [];
+  const parts = text.split(/^##\s+/m).slice(1);
+  for (const p of parts) {
+    const [head, ...rest] = p.split(/\r?\n/);
+    const version = /v?(\d+\.\d+\.\d+(?:-[\w.]+)?)/.exec(head ?? "")?.[1];
+    if (!version) continue;
+    const body = rest.join("\n");
+    const shas = [...new Set([...body.matchAll(/(?:^|[\s[`(])([0-9a-f]{7,40})(?=[\s`\]):]|$)/gm)].map((m) => m[1]))];
+    const prs = [...new Set([...body.matchAll(/(?:#|\/pull\/)(\d+)/g)].map((m) => Number(m[1])))];
+    const date2 = /(\d{4}-\d{2}-\d{2})/.exec(head ?? "")?.[1];
+    out.push({ version, ...date2 ? { date: date2 } : {}, shas, prs });
+  }
+  return out;
+}
+function releasesFromTags(tags, pkg) {
+  const out = [];
+  for (const t of tags) {
+    const m = /^(?:(@?[^@\s]+)@)?v?(\d+\.\d+\.\d+(?:-[\w.]+)?)$/.exec(t.name);
+    if (!m) continue;
+    if (pkg && m[1] && m[1] !== pkg) continue;
+    out.push({ version: m[2], ...t.sha ? { sha: t.sha } : {}, ...t.date ? { date: t.date } : {} });
+  }
+  return out;
+}
+function assignVersions(entries, releases) {
+  const dated = releases.filter((r) => r.date).sort((a, b) => Date.parse(a.date) - Date.parse(b.date));
+  return entries.map((e) => {
+    const cited = releases.find((r) => r.shas?.some((s) => e.sha.startsWith(s)) || e.pr && r.prs?.includes(e.pr.number));
+    const byTag = cited ? void 0 : dated.find((r) => r.sha === e.sha || Date.parse(r.date) >= Date.parse(e.date));
+    return { ...e, version: (cited ?? byTag)?.version ?? UNRELEASED };
+  });
+}
+var BUMP_RANK2 = { patch: 0, minor: 1, major: 2 };
+function versionTimeline(entries, releases = []) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const v = e.version ?? UNRELEASED;
+    let g = groups.get(v);
+    if (!g) {
+      const rel = releases.find((r) => r.version === v);
+      g = { version: v, pending: v === UNRELEASED, date: rel?.date ?? e.date, entries: [], prs: [], tokenChanges: 0, breaking: false, bump: "patch", authors: [] };
+      groups.set(v, g);
+    }
+    g.entries.push(e.id);
+    if (e.pr && !g.prs.includes(e.pr.number)) g.prs.push(e.pr.number);
+    g.tokenChanges += e.counts.total;
+    g.breaking ||= e.breaking;
+    if (BUMP_RANK2[e.bump] > BUMP_RANK2[g.bump]) g.bump = e.bump;
+    if (!g.authors.includes(e.author)) g.authors.push(e.author);
+    if (!releases.some((r) => r.version === v && r.date) && Date.parse(e.date) > Date.parse(g.date)) g.date = e.date;
+  }
+  return [...groups.values()].sort((a, b) => a.pending ? -1 : b.pending ? 1 : Date.parse(b.date) - Date.parse(a.date));
+}
+function packageDirCandidates(config) {
+  const parts = config.tokens.root.replace(/\/$/, "").split("/").filter((p) => p && p !== ".");
+  const out = [];
+  for (let i = parts.length; i >= 0; i--) out.push(parts.slice(0, i).join("/"));
+  return out;
+}
+function mergeReleases(changelog, tags) {
+  const byVersion = /* @__PURE__ */ new Map();
+  for (const r of [...changelog, ...tags]) {
+    const prev = byVersion.get(r.version);
+    byVersion.set(r.version, prev ? { ...r, ...prev, ...prev.date ? {} : r.date ? { date: r.date } : {}, ...prev.sha ? {} : r.sha ? { sha: r.sha } : {} } : r);
+  }
+  return [...byVersion.values()];
+}
+function buildReport(args) {
+  const entries = assignVersions(args.entries, args.releases).sort((a, b) => Date.parse(b.date) - Date.parse(a.date));
+  return { ...args, entries, timeline: versionTimeline(entries, args.releases) };
+}
 
 // ../core/src/node/audit.ts
 import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
@@ -4050,6 +4479,33 @@ var EXPLORATION_USE_CASES = [
 ];
 var EXPLORATION_STATUS_LABEL = { active: "Running", promoted: "Promoted to review", closed: "Closed" };
 
+// ../core/src/titles.ts
+var escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function properWord(word, names) {
+  const bare = word.replace(/[^\p{L}\p{N}]+$/u, "");
+  if (!bare) return false;
+  if (names.some((n) => n === bare)) return true;
+  return new RegExp("\\p{Lu}", "u").test(bare.slice(1));
+}
+function lowerFirstWord(text, names = []) {
+  const first = text.split(/\s+/)[0] ?? "";
+  if (!first || properWord(first, names)) return text;
+  return `${text.charAt(0).toLowerCase()}${text.slice(1)}`;
+}
+function subjectTitle(subject, title, names = []) {
+  const t = title.trim().replace(/\.$/, "");
+  const keep = [subject, ...names];
+  const s = subject.trim();
+  if (!s) return t;
+  const m = new RegExp(`^${escape(s)}(?=$|[^\\p{L}\\p{N}])\\s*(:)?\\s*`, "iu").exec(t);
+  if (m) {
+    const rest = t.slice(m[0].length);
+    if (!rest) return s;
+    return m[1] ? `${s}: ${lowerFirstWord(rest, keep)}` : `${s} ${rest}`;
+  }
+  return `${s}: ${lowerFirstWord(t, keep)}`;
+}
+
 // ../core/src/requests.ts
 var REQUEST_KINDS = [
   { value: "new-component", label: "New component", hint: "A component the design system does not have yet." },
@@ -4062,11 +4518,33 @@ var REQUEST_KINDS = [
   { value: "other", label: "Other", hint: "Anything else." }
 ];
 var REQUEST_LABEL = "component-change";
+var MARK = "bridge-request";
 function requestIssueTitle(r) {
-  const t = r.title.trim().replace(/\.$/, "");
-  return `${r.component}: ${t.charAt(0).toLowerCase()}${t.slice(1)}`;
+  return subjectTitle(r.component, r.title);
+}
+function parseRequestIssue(body) {
+  if (!body) return void 0;
+  const m = new RegExp(`<!-- ${MARK} (\\{[\\s\\S]*?\\}) -->`).exec(body);
+  if (!m) return void 0;
+  try {
+    const r = JSON.parse(m[1]);
+    return r && typeof r.component === "string" && typeof r.title === "string" ? { ...r, changes: Array.isArray(r.changes) ? r.changes : [] } : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function requestStatus(issue) {
+  const prs = issue.linkedPrs ?? [];
+  if (issue.state === "open") return prs.some((p) => p.state === "open") ? "in-progress" : "requested";
+  if (prs.some((p) => p.merged) || issue.stateReason === "completed") return "done";
+  return "declined";
 }
 var REQUEST_STATUS_LABEL = { requested: "Requested", "in-progress": "In progress", done: "Done", declined: "Declined" };
+function closingIssueNumbers(body) {
+  const out = /* @__PURE__ */ new Set();
+  for (const m of (body ?? "").matchAll(/\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\s+#(\d+)/gi)) out.add(Number(m[1]));
+  return [...out];
+}
 function validateIntegrations(i) {
   const out = [];
   if (!i?.jira) return out;
@@ -4095,7 +4573,185 @@ function jiraIssueFields(r, jira, issueUrl) {
   };
 }
 
+// ../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 summarizeApprovals(reviews, owners, author, rules = {}) {
+  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 solo = rules.soloOwnerCanApproveBoth ? soloApprover(owners) : null;
+    const soloBoth = (x) => a.length === 1 && d.includes(x) && x !== solo;
+    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.";
+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 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]);
+}
+
+// ../core/src/suggestion-review.ts
+var SUGGESTION_REVIEW_MARK = "bridge-suggestion-review";
+var SUGGESTION_APPLIED_MARK = "bridge-suggestion-applied";
+var EVENTS = ["approve", "request-changes", "comment"];
+function parseSuggestionReviewComment(body) {
+  const m = new RegExp(`<!-- ${SUGGESTION_REVIEW_MARK} (\\{[^\\n]*?\\}) -->`).exec(body ?? "");
+  if (!m) return null;
+  try {
+    const r = JSON.parse(m[1]);
+    if (!r || !EVENTS.includes(r.event) || typeof r.payloadSha !== "string" || !/^[0-9a-f]{64}$/.test(r.payloadSha)) return null;
+    return {
+      event: r.event,
+      ...r.role === "design" || r.role === "tech" || r.role === "approval" ? { role: r.role } : {},
+      payloadSha: r.payloadSha,
+      at: typeof r.at === "string" ? r.at : ""
+    };
+  } catch {
+    return null;
+  }
+}
+function parseSuggestionAppliedComment(body) {
+  const m = new RegExp(`<!-- ${SUGGESTION_APPLIED_MARK} (\\{[^\\n]*?\\}) -->`).exec(body ?? "");
+  if (!m) return null;
+  try {
+    const r = JSON.parse(m[1]);
+    return r && typeof r.payloadSha === "string" ? { ...r, payloadSha: r.payloadSha, at: typeof r.at === "string" ? r.at : "" } : null;
+  } catch {
+    return null;
+  }
+}
+var norm3 = (l) => l.trim().replace(/^@/, "").toLowerCase();
+var COLLABORATOR = ["OWNER", "MEMBER", "COLLABORATOR"];
+function summarizeSuggestionApprovals(comments, gov, opts) {
+  const lists = approverLists(gov.owners, gov.rights ?? null, gov.teams);
+  const owners = new Set([...lists.design, ...lists.tech].map(norm3));
+  const anyOwner = owners.size > 0;
+  const reviews = [];
+  const latestOld = /* @__PURE__ */ new Map();
+  const ignored = /* @__PURE__ */ new Set();
+  const ordered = comments.map((c, i) => ({ c, i })).sort((a, b) => String(a.c.createdAt ?? "").localeCompare(String(b.c.createdAt ?? "")) || a.i - b.i);
+  ordered.forEach(({ c }, i) => {
+    const r = parseSuggestionReviewComment(c.body);
+    if (!r || r.event === "comment" || !c.author) return;
+    const login = norm3(c.author);
+    if (opts.author && login === norm3(opts.author)) return;
+    const counts = anyOwner ? owners.has(login) : COLLABORATOR.includes((c.authorAssociation ?? "").toUpperCase());
+    if (!counts) {
+      ignored.add(c.author);
+      return;
+    }
+    const at = String(i).padStart(6, "0");
+    if (r.payloadSha !== opts.payloadSha) {
+      latestOld.set(c.author, r.event);
+      reviews.push({ user: { login: c.author }, state: "DISMISSED", submitted_at: at });
+      return;
+    }
+    latestOld.delete(c.author);
+    reviews.push({ user: { login: c.author }, state: r.event === "approve" ? "APPROVED" : "CHANGES_REQUESTED", submitted_at: at });
+  });
+  const summary = summarizeApprovals(reviews, lists, opts.author ?? void 0, { soloOwnerCanApproveBoth: gov.soloOwnerCanApproveBoth });
+  const stale = [...latestOld.keys()].filter((l) => !summary.approvers.includes(l) && !summary.changesRequested.includes(l));
+  return { ...summary, stale, ignored: [...ignored].filter((l) => !summary.approvers.includes(l)) };
+}
+function suggestionReviewState(tier, approvals) {
+  if (approvals.changesRequested.length) return "changes-requested";
+  return pendingApprovals(tier, approvals).length ? "needs-review" : "approved";
+}
+
 // ../core/src/suggestions.ts
+var SUGGESTION_SCHEMA = "bridge.suggestion/1";
+var SUGGESTION_LABEL = "bridge-suggestion";
+var SUGGESTION_KINDS = ["token-change", "docs", "component-spec", "brand", "revert", "config"];
+var SUGGESTION_STATE_LABELS = {
+  "needs-review": "suggestion: needs review",
+  "changes-requested": "suggestion: changes requested",
+  approved: "suggestion: approved",
+  applying: "suggestion: applying"
+};
+var SUGGESTION_FINAL_LABELS = {
+  applied: "suggestion: applied",
+  declined: "suggestion: declined"
+};
 var SUGGESTION_STATUS_LABEL = {
   "needs-review": "Needs review",
   "changes-requested": "Changes requested",
@@ -4105,6 +4761,328 @@ var SUGGESTION_STATUS_LABEL = {
   declined: "Declined",
   outdated: "Outdated"
 };
+var SUGGESTION_LIMITS = {
+  body: 65536,
+  /** The readable part of the body (tables are cut with "and N more"). */
+  human: 12e3,
+  /** The JSON block in the body. */
+  inline: 48e3,
+  /** The JSON block of one continuation comment. */
+  part: 6e4,
+  /** Continuation comments at most (about 480 KB of file contents). */
+  maxParts: 8
+};
+var utf8 = (text) => new TextEncoder().encode(text);
+var hex = (words) => words.map((w) => (w >>> 0).toString(16).padStart(8, "0")).join("");
+function padded(bytes) {
+  const len = bytes.length;
+  const total = Math.ceil((len + 9) / 64) * 64;
+  const buf = new Uint8Array(total);
+  buf.set(bytes);
+  buf[len] = 128;
+  const view = new DataView(buf.buffer);
+  view.setUint32(total - 8, Math.floor(len / 536870912), false);
+  view.setUint32(total - 4, len * 8 >>> 0, false);
+  return view;
+}
+var K256 = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+function sha256Hex(text) {
+  const view = padded(utf8(text));
+  const h = [1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225];
+  const w = new Array(64);
+  const rotr = (x, n) => x >>> n | x << 32 - n;
+  for (let off = 0; off < view.byteLength; off += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(off + i * 4, false);
+    for (let i = 16; i < 64; i++) {
+      const a2 = w[i - 15];
+      const b2 = w[i - 2];
+      const s0 = rotr(a2, 7) ^ rotr(a2, 18) ^ a2 >>> 3;
+      const s1 = rotr(b2, 17) ^ rotr(b2, 19) ^ b2 >>> 10;
+      w[i] = w[i - 16] + s0 + w[i - 7] + s1 | 0;
+    }
+    let [a, b, c, d, e, f, g, hh] = h;
+    for (let i = 0; i < 64; i++) {
+      const t1 = hh + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + (e & f ^ ~e & g) + K256[i] + w[i] | 0;
+      const t2 = (rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + (a & b ^ a & c ^ b & c) | 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + t1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 | 0;
+    }
+    h[0] = h[0] + a | 0;
+    h[1] = h[1] + b | 0;
+    h[2] = h[2] + c | 0;
+    h[3] = h[3] + d | 0;
+    h[4] = h[4] + e | 0;
+    h[5] = h[5] + f | 0;
+    h[6] = h[6] + g | 0;
+    h[7] = h[7] + hh | 0;
+  }
+  return hex(h);
+}
+function canonicalJson(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(v) {
+  if (Array.isArray(v)) return v.map((x) => x === void 0 ? null : sortKeys(x));
+  if (v && typeof v === "object" && !(v.toJSON instanceof Function)) {
+    const out = {};
+    for (const k of Object.keys(v).sort()) {
+      const x = v[k];
+      if (x !== void 0) out[k] = sortKeys(x);
+    }
+    return out;
+  }
+  return v;
+}
+function shaForm(p) {
+  if (!p.files) return p;
+  return { ...p, files: p.files.map(({ part: _part, ...f }) => f) };
+}
+function suggestionPayloadSha(p) {
+  return sha256Hex(canonicalJson(shaForm(p)));
+}
+function suggestionKindFromLabels(labels) {
+  for (const l of labels) {
+    const m = /^suggestion: (.+)$/.exec(l);
+    if (m && SUGGESTION_KINDS.includes(m[1])) return m[1];
+  }
+  return void 0;
+}
+function suggestionStateFromLabels(labels) {
+  return Object.entries(SUGGESTION_STATE_LABELS).find(([, l]) => labels.includes(l))?.[0];
+}
+function suggestionStatus(i) {
+  const prs = i.linkedPrs ?? [];
+  if (i.state === "closed") return prs.some((p) => p.merged) || i.stateReason === "completed" ? "applied" : "declined";
+  if (prs.some((p) => p.state === "open") || i.applied) return "applying";
+  if (i.outdated) return "outdated";
+  return i.review ?? "needs-review";
+}
+var SUGGESTION_STATUS_LABELS = [...Object.values(SUGGESTION_STATE_LABELS), ...Object.values(SUGGESTION_FINAL_LABELS)];
+var MARK2 = "bridge-suggestion";
+var PART_SCHEMA = "bridge.suggestion-part/1";
+function fencedAfter(text, from) {
+  const m = /```json\r?\n([\s\S]*?)\r?\n```/.exec(text.slice(from));
+  return m?.[1];
+}
+var fail = (reason, message) => ({ ok: false, reason, message });
+function parseSuggestionIssue(body, opts = {}) {
+  const text = body ?? "";
+  const markers = [...text.matchAll(new RegExp(`^<!-- ${MARK2}:v(\\d+) sha256=([0-9a-f]{64})(?: parts=(\\d+))? -->$`, "gm"))];
+  const marker = markers[markers.length - 1];
+  if (!marker) return fail("no-block", "This issue has no Bridge suggestion block.");
+  if (marker[1] !== "1") return fail("unsupported-version", `This suggestion uses version ${marker[1]} of the format. Update Bridge to read it.`);
+  const json = fencedAfter(text, marker.index + marker[0].length);
+  if (json === void 0) return fail("invalid", "The suggestion block has no JSON. Someone may have edited it by hand: ask the author to send it again.");
+  let raw;
+  try {
+    raw = JSON.parse(json);
+  } catch {
+    return fail("invalid", "The suggestion JSON does not parse. Someone may have edited it by hand: ask the author to send it again.");
+  }
+  const schema = raw?.schema;
+  if (typeof schema === "string" && schema !== SUGGESTION_SCHEMA) {
+    const v = /^bridge\.suggestion\/(\d+)$/.exec(schema);
+    return v ? fail("unsupported-version", `This suggestion uses ${schema}. Update Bridge to read it.`) : fail("invalid", `"${schema}" is not a Bridge suggestion schema.`);
+  }
+  const problems = suggestionShapeProblems(raw);
+  if (problems.length) return fail("invalid", `The suggestion block is not valid: ${problems.join(" ")}`);
+  const payload = raw;
+  const markedSha = marker[2];
+  const expected = marker[3] ? Number(marker[3]) : 0;
+  let edited = false;
+  if (expected > 0 || payload.files?.some((f) => f.part !== void 0)) {
+    const want = Math.max(expected, ...(payload.files ?? []).map((f) => f.part ?? 0));
+    const found = /* @__PURE__ */ new Map();
+    const author = opts.author?.toLowerCase();
+    for (const c of opts.comments ?? []) {
+      if (author && c.author && c.author.toLowerCase() !== author) continue;
+      const m = new RegExp(`^<!-- ${MARK2}:v1 part (\\d+)/(\\d+) sha256=([0-9a-f]{64}) -->$`, "m").exec(c.body);
+      if (!m) continue;
+      const i = Number(m[1]);
+      if (found.has(i)) continue;
+      const pj = fencedAfter(c.body, m.index + m[0].length);
+      if (pj === void 0) continue;
+      if (sha256Hex(pj) !== m[3]) edited = true;
+      try {
+        const part = JSON.parse(pj);
+        if (part.schema !== PART_SCHEMA || !Array.isArray(part.files)) continue;
+        found.set(i, part.files.filter((x) => x && typeof x.i === "number" && typeof x.text === "string"));
+      } catch {
+        continue;
+      }
+    }
+    for (let i = 1; i <= want; i++) {
+      if (!found.has(i)) return fail("missing-part", `This suggestion is incomplete: part ${i} of ${want} is missing. It is still being written, or a comment was deleted: ask the author to send it again.`);
+    }
+    const files = (payload.files ?? []).map((f, idx) => {
+      if (f.part === void 0) return f;
+      let content = "";
+      for (let i = 1; i <= want; i++) for (const ch of found.get(i)) if (ch.i === idx && ch.path === f.path) content += ch.text;
+      const { part: _part, ...rest } = f;
+      return { ...rest, content };
+    });
+    payload.files = files;
+  }
+  const sha = suggestionPayloadSha(payload);
+  return { ok: true, payload, sha, markedSha, edited: edited || sha !== markedSha, parts: expected };
+}
+function suggestionShapeProblems(raw) {
+  const out = [];
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return ["The payload must be a JSON object."];
+  const p = raw;
+  if (p.schema !== SUGGESTION_SCHEMA) out.push(`"schema" must be "${SUGGESTION_SCHEMA}".`);
+  if (!SUGGESTION_KINDS.includes(p.kind)) out.push(`"kind" must be one of ${SUGGESTION_KINDS.join(", ")}.`);
+  if (typeof p.title !== "string" || !p.title.trim()) out.push('"title" must be a sentence.');
+  if (typeof p.summary !== "string") out.push('"summary" must be text.');
+  if (!["figma", "studio", "cli", "mcp"].includes(p.source)) out.push('"source" must be figma, studio, cli or mcp.');
+  if (typeof p.createdAt !== "string") out.push('"createdAt" must be an ISO date.');
+  const base = p.base;
+  if (!base || typeof base.ref !== "string" || typeof base.sha !== "string" || !/^[0-9a-f]{7,64}$/.test(base.sha)) out.push('"base" must be { "ref", "sha" } with the commit the change was planned on.');
+  const tier = p.tier;
+  if (!tier || ![1, 2, 3].includes(tier.tier) || !["patch", "minor", "major"].includes(tier.bump)) out.push('"tier" must be { "tier": 1, 2 or 3, "bump": patch, minor or major }.');
+  const checks = p.checks;
+  if (!checks || typeof checks.newErrors !== "number" || !Array.isArray(checks.contrast) || typeof checks.impact !== "number" || !(checks.blocked === null || typeof checks.blocked === "string"))
+    out.push('"checks" must be { "newErrors", "contrast", "blocked", "impact" }.');
+  const tokens2 = p.tokens;
+  if (tokens2 !== void 0 && (!tokens2 || !Array.isArray(tokens2.edits) || !Array.isArray(tokens2.changes))) out.push('"tokens" must be { "edits", "changes" }.');
+  if (p.docs !== void 0 && !(Array.isArray(p.docs) && p.docs.every((d) => d && typeof d.component === "string" && typeof d.path === "string"))) out.push('"docs" must be a list of { "component", "path", "after" }.');
+  const spec = p.componentSpec;
+  if (spec !== void 0 && (!spec || typeof spec.component !== "string" || typeof spec.specPath !== "string" || typeof spec.brief !== "string")) out.push('"componentSpec" must be { "component", "specPath", "spec", "brief" }.');
+  const nodes = p.links?.figma?.nodes;
+  if (nodes !== void 0 && !(Array.isArray(nodes) && nodes.every((n) => n && typeof n.nodeId === "string"))) out.push('"links.figma.nodes" must be a list of { "nodeId", "url"?, "name"?, "state"? }.');
+  if (p.files !== void 0) {
+    if (!Array.isArray(p.files)) out.push('"files" must be a list.');
+    else {
+      const seen = /* @__PURE__ */ new Set();
+      for (const f of p.files) {
+        const ok = f && typeof f.path === "string" && (f.beforeSha === null || typeof f.beforeSha === "string") && (f.afterSha === null || typeof f.afterSha === "string") && (f.content === void 0 || f.content === null || typeof f.content === "string") && (f.part === void 0 || Number.isInteger(f.part) && f.part >= 1 && f.part <= SUGGESTION_LIMITS.maxParts);
+        if (!ok) {
+          out.push('Each of "files" must be { "path", "beforeSha", "afterSha", "content"? }.');
+          break;
+        }
+        if (seen.has(f.path)) out.push(`"${f.path}" is listed twice in "files".`);
+        seen.add(f.path);
+      }
+    }
+  }
+  return out;
+}
+
+// ../core/src/suggestions-github.ts
+function linkedPullsOf(n, pulls) {
+  return pulls.filter((p) => closingIssueNumbers(p.body).includes(n)).map((p) => ({ number: p.number, url: p.url, state: p.state === "open" ? "open" : "closed", merged: p.state === "merged" }));
+}
+async function listSuggestionsOnGitHub(gh, opts = {}) {
+  const issues = await gh.listIssues({ label: SUGGESTION_LABEL, state: opts.state ?? "open", perPage: opts.perPage ?? 50 });
+  const pulls = opts.pulls ?? (issues.length ? await gh.listPullRequests("all").catch(() => []) : []);
+  return issues.map((i) => listItem(i, pulls));
+}
+function listItem(i, pulls) {
+  const linkedPrs = linkedPullsOf(i.number, pulls);
+  const cached = suggestionStateFromLabels(i.labels);
+  const t = i.labels.map((l) => /^tier: ([123])$/.exec(l)?.[1]).find(Boolean);
+  return {
+    number: i.number,
+    title: i.title,
+    url: i.url,
+    author: i.author,
+    createdAt: i.createdAt,
+    state: i.state,
+    stateReason: i.stateReason,
+    labels: i.labels,
+    kind: suggestionKindFromLabels(i.labels),
+    tier: t ? Number(t) : void 0,
+    linkedPrs,
+    status: suggestionStatus({ state: i.state, stateReason: i.stateReason, linkedPrs, applied: cached === "applying", review: cached === "applying" ? void 0 : cached })
+  };
+}
+async function getSuggestionOnGitHub(gh, n, gov, opts = {}) {
+  const [issue, comments, pulls] = await Promise.all([gh.getIssue(n), gh.listIssueComments(n), opts.pulls ? Promise.resolve(opts.pulls) : gh.listPullRequests("all").catch(() => [])]);
+  const parsed = parseSuggestionIssue(issue.body, { comments, author: issue.author || void 0 });
+  const linkedPrs = linkedPullsOf(n, pulls);
+  const applied = comments.flatMap((c) => parseSuggestionAppliedComment(c.body) ?? []);
+  const approvals = parsed.ok ? summarizeSuggestionApprovals(comments, gov, { payloadSha: parsed.sha, author: issue.author }) : void 0;
+  const status = suggestionStatus({
+    state: issue.state,
+    stateReason: issue.stateReason,
+    linkedPrs,
+    applied: parsed.ok && applied.some((a) => a.payloadSha === parsed.sha),
+    outdated: opts.outdated,
+    review: parsed.ok && approvals ? suggestionReviewState(parsed.payload.tier.tier, approvals) : void 0
+  });
+  return { issue, parsed, comments, approvals, linkedPrs, applied, status };
+}
 
 // ../core/src/suggestion-apply.ts
 var SUGGESTION_APPLY_EXIT = {
@@ -4311,7 +5289,7 @@ function importsIn(text) {
   for (const m of text.matchAll(IMPORT_RE)) out.add(m[1] ?? m[2]);
   return [...out];
 }
-var norm2 = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "");
+var norm4 = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "");
 var isStory = (p) => /\.stories\.[cm]?[jt]sx?$/.test(p);
 var isTest = (p) => /\.(test|spec)\.[cm]?[jt]sx?$/.test(p);
 var isCss = (p) => /\.(css|scss|less)$/.test(p);
@@ -4329,14 +5307,14 @@ function componentOf(from, spec, componentsDir) {
   return abs.slice(componentsDir.length + 1).split("/")[0] || null;
 }
 function componentForPath(path, componentsDir) {
-  const dir = norm2(componentsDir);
-  const p = norm2(path);
+  const dir = norm4(componentsDir);
+  const p = norm4(path);
   if (!p.startsWith(`${dir}/`)) return null;
   const rest = p.slice(dir.length + 1).split("/");
   return rest.length >= 2 ? rest[0] : null;
 }
 function buildUsageIndex(files, componentsDir) {
-  const dir = norm2(componentsDir);
+  const dir = norm4(componentsDir);
   const modules = {};
   const vars = /* @__PURE__ */ new Map();
   const imports = /* @__PURE__ */ new Map();
@@ -4344,7 +5322,7 @@ function buildUsageIndex(files, componentsDir) {
   const globalVars = {};
   const get = (m, k) => m.get(k) ?? m.set(k, /* @__PURE__ */ new Set()).get(k);
   for (const f of files) {
-    const path = norm2(f.path);
+    const path = norm4(f.path);
     const id = componentForPath(path, dir);
     if (!id) {
       if (isCss(path)) {
@@ -4388,7 +5366,7 @@ function impactedModules(index, input) {
   for (const v of changedVars) for (const id of index.byVar[v] ?? []) add(id, `uses ${v}`, false);
   for (const f of input.files ?? []) {
     const id = componentForPath(f, index.componentsDir);
-    if (id && index.modules[id]) add(id, `file changed: ${norm2(f)}`, false);
+    if (id && index.modules[id]) add(id, `file changed: ${norm4(f)}`, false);
   }
   const renderedBy = /* @__PURE__ */ new Map();
   for (const m of Object.values(index.modules)) for (const d of m.imports) (renderedBy.get(d) ?? renderedBy.set(d, []).get(d)).push(m.id);
@@ -4406,6 +5384,131 @@ function impactedModules(index, input) {
   return { modules, globalHits };
 }
 
+// ../core/src/history-github.ts
+function gitHubHistoryBackend(client, config, opts = {}) {
+  const trees = /* @__PURE__ */ new Map();
+  const tree = (sha) => {
+    let t = trees.get(sha);
+    if (!t) {
+      t = client.getCommitTree(sha).then((ts2) => client.getTree(ts2, true)).then((r) => r.entries);
+      trees.set(sha, t);
+    }
+    return t;
+  };
+  const body = async (sha, e) => (!client.canWrite ? await client.readRawFile(e.path, sha).catch(() => void 0) : void 0) ?? client.getBlobText(e.sha);
+  const root = config.tokens.root.replace(/\/$/, "");
+  const prefix = root === "." || !root ? "" : `${root}/`;
+  const limit = Math.max(1, opts.concurrency ?? 4);
+  const pool = async (items, fn) => {
+    const out = new Array(items.length);
+    let i = 0;
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, async () => {
+      for (let k = i++; k < items.length; k = i++) out[k] = await fn(items[k]);
+    }));
+    return out;
+  };
+  return {
+    tree,
+    async listCommits({ ref, paths, limit: max }) {
+      const commits = [];
+      for (let page = 1; commits.length < max && page <= 10; page++) {
+        const batch = await client.listCommits({ sha: ref, path: paths[0], perPage: Math.min(100, max), page });
+        for (const c of batch) {
+          const [subject, ...rest] = c.message.split("\n");
+          commits.push({ sha: c.sha, parents: c.parents, date: c.date, author: c.author, subject: subject ?? "", body: rest.join("\n").trim() });
+        }
+        if (batch.length < Math.min(100, max)) break;
+      }
+      const list2 = commits.slice(0, max);
+      const merges = /* @__PURE__ */ new Map();
+      const enriched = await pool(list2, async (c) => {
+        const prs = await client.listPullRequestsForCommit(c.sha).catch(() => []);
+        const pr = prs.find((p) => p.mergedAt && p.baseRef === ref) ?? prs.find((p) => p.mergedAt);
+        if (!pr) return c;
+        const prInfo = { number: pr.number, title: pr.title, url: pr.url, author: pr.author, ...pr.mergedAt ? { mergedAt: pr.mergedAt } : {}, body: pr.body };
+        if (pr.mergeCommitSha && pr.mergeCommitSha !== c.sha) {
+          let m = merges.get(pr.mergeCommitSha);
+          if (!m) {
+            m = client.getCommitInfo(pr.mergeCommitSha).then(
+              (info) => {
+                const [subject, ...rest] = info.message.split("\n");
+                return { sha: info.sha, parents: info.parents, date: pr.mergedAt ?? info.date, author: info.author, subject: subject ?? "", body: rest.join("\n").trim() };
+              },
+              () => void 0
+            );
+            merges.set(pr.mergeCommitSha, m);
+          }
+          const merge = await m;
+          if (merge) return { ...merge, pr: prInfo };
+        }
+        return { ...c, ...pr.mergedAt ? { date: pr.mergedAt } : {}, pr: prInfo };
+      });
+      return enriched;
+    },
+    async tokenFiles(sha) {
+      const entries = await tree(sha);
+      const blobs = entries.filter((e) => e.type === "blob" && e.path.startsWith(prefix));
+      const picked = new Set(selectTokenFiles(config, blobs.map((e) => e.path)));
+      const wanted = blobs.filter((e) => picked.has(prefix ? e.path.slice(prefix.length) : e.path));
+      const texts = await pool(wanted, async (e) => [prefix ? e.path.slice(prefix.length) : e.path, await body(sha, e)]);
+      return new Map(texts);
+    },
+    async changesetPaths(sha) {
+      const dir = config.changesets?.dir.replace(/\/$/, "");
+      if (!dir) return [];
+      return (await tree(sha)).filter((e) => e.type === "blob" && e.path.startsWith(`${dir}/`)).map((e) => e.path);
+    },
+    async readFile(sha, path) {
+      const e = (await tree(sha)).find((x) => x.type === "blob" && x.path === path);
+      return e ? body(sha, e) : null;
+    }
+  };
+}
+async function loadGitHubHistory(client, config, opts = {}) {
+  const ref = opts.ref ?? config.repo?.defaultBranch ?? await client.getDefaultBranch();
+  const limit = opts.limit ?? 30;
+  const backend = gitHubHistoryBackend(client, config);
+  let listed = 0;
+  const counted = { ...backend, listCommits: async (o) => {
+    const r = await backend.listCommits(o);
+    listed = r.length;
+    return r;
+  } };
+  const entries = await collectHistory(config, counted, { ref, limit, ...opts.onProgress ? { onProgress: opts.onProgress } : {} });
+  const head = await client.getBranchSha(ref).catch(() => void 0);
+  let changelog = [];
+  let currentVersion;
+  if (head) {
+    const files = await backend.tree(head).catch(() => []);
+    for (const dir of packageDirCandidates(config)) {
+      const p = (f) => dir ? `${dir}/${f}` : f;
+      const cl = files.find((e) => e.path === p("CHANGELOG.md"));
+      const pkg = files.find((e) => e.path === p("package.json"));
+      if (!cl && !pkg) continue;
+      if (cl) changelog = parseChangelog(await client.getBlobText(cl.sha));
+      if (pkg) {
+        try {
+          const json = JSON.parse(await client.getBlobText(pkg.sha));
+          if (!config.changesets || json.name === config.changesets.package) currentVersion = json.version;
+        } catch {
+        }
+      }
+      break;
+    }
+  }
+  const tagList = await client.listTags(30).catch(() => []);
+  const tagReleases = releasesFromTags(tagList, config.changesets?.package);
+  await Promise.all(
+    tagReleases.slice(0, 10).map(async (r) => {
+      if (!r.sha) return;
+      const info = await client.getCommitInfo(r.sha).catch(() => void 0);
+      if (info?.date) r.date = info.date;
+    })
+  );
+  const releases = mergeReleases(changelog, tagReleases);
+  return buildReport({ source: "github", label: `${client.fullName}@${ref}`, ref, entries, releases, ...currentVersion ? { currentVersion } : {}, truncated: listed >= limit });
+}
+
 // ../core/src/fidelity-references.ts
 var FIGMA_REFERENCES_DIR = "figma-references";
 var FIGMA_REFERENCES_MANIFEST = `${FIGMA_REFERENCES_DIR}/manifest.json`;
@@ -4678,10 +5781,10 @@ function colorCss(c) {
   if (typeof c === "string") return { css: c, hex: /^#[0-9a-f]{6}$/i.test(c) ? c.toLowerCase() : void 0 };
   const v = c;
   const [r = 0, g = 0, b = 0] = v.components;
-  const hex = (v.hex ?? `#${[r, g, b].map(toHex22).join("")}`).toLowerCase();
+  const hex2 = (v.hex ?? `#${[r, g, b].map(toHex22).join("")}`).toLowerCase();
   const alpha = v.alpha ?? 1;
-  if (alpha < 1) return { css: `rgb(${[r, g, b].map((x) => Math.round(x * 255)).join(" ")} / ${alpha})`, hex };
-  return { css: hex, hex };
+  if (alpha < 1) return { css: `rgb(${[r, g, b].map((x) => Math.round(x * 255)).join(" ")} / ${alpha})`, hex: hex2 };
+  return { css: hex2, hex: hex2 };
 }
 var dimCss = (d) => typeof d === "object" && d !== null ? `${d.value}${d.unit}` : String(d);
 function shadowCss(s) {
@@ -4735,13 +5838,13 @@ function buildTokenRows(config, readText, listFiles) {
     ...componentFiles
   ];
   const primitives = primitiveFiles.flatMap((f) => flatFile(f)).map((t) => {
-    const { css, hex } = tokenValueCss(t.type, t.value);
+    const { css, hex: hex2 } = tokenValueCss(t.type, t.value);
     return {
       path: t.path.join("."),
       segments: t.path,
       type: t.type,
       css,
-      hex,
+      hex: hex2,
       cssVar: tokenRowCssVar(t.path),
       figma: tokenRowFigmaName(t.path),
       description: t.description,
@@ -4785,8 +5888,8 @@ function buildTokenRows(config, readText, listFiles) {
       current = hit.value;
       currentType = hit.type || currentType;
     }
-    const { css, hex } = tokenValueCss(currentType, current);
-    return { alias: chain[0] ?? null, chain, css, hex };
+    const { css, hex: hex2 } = tokenValueCss(currentType, current);
+    return { alias: chain[0] ?? null, chain, css, hex: hex2 };
   };
   const same2 = (a, c) => a.css === c.css && a.chain.join() === c.chain.join();
   const build = (t, tier, valueFor) => {
@@ -4846,8 +5949,8 @@ var channel = (c) => {
   const s = c / 255;
   return s <= 0.04045 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
 };
-function hexLuminance(hex) {
-  const n = parseInt(hex.slice(1), 16);
+function hexLuminance(hex2) {
+  const n = parseInt(hex2.slice(1), 16);
   return 0.2126 * channel(n >> 16 & 255) + 0.7152 * channel(n >> 8 & 255) + 0.0722 * channel(n & 255);
 }
 function hexContrastRatio(a, b) {
@@ -5038,7 +6141,7 @@ function scanComponents(input) {
   const docsSuffix = input.docsSuffix ?? ".docs.json";
   const styleSuffix = input.styleSuffix ?? ".module.css";
   const fileSet = new Set(input.files);
-  const has8 = (p) => fileSet.has(p);
+  const has9 = (p) => fileSet.has(p);
   const fam = input.indexText === void 0 ? [] : parseComponentFamilies(input.indexText, input.indexRel ?? "components");
   const familyOf = (name) => fam.find((f) => f.members.includes(name))?.name;
   const names = [
@@ -5051,7 +6154,7 @@ function scanComponents(input) {
     const folder = `${dir}/${name}`;
     const files = { tsx: `${folder}/${name}.tsx`, css: `${folder}/${name}${styleSuffix}`, stories: `${folder}/${name}.stories.tsx`, docs: `${folder}/${name}${docsSuffix}` };
     let docs = null;
-    if (has8(files.docs)) {
+    if (has9(files.docs)) {
       try {
         docs = JSON.parse(readText(files.docs) ?? "");
       } catch (err) {
@@ -5061,10 +6164,10 @@ function scanComponents(input) {
     const tsxSrc = readText(files.tsx) ?? "";
     const tsx = parseComponentTsx(name, tsxSrc);
     const reuses = [...tsxSrc.matchAll(reuseRe)].filter((m) => m[1] === m[2] && m[1] !== name).map((m) => m[1]);
-    const cssText = has8(files.css) ? readText(files.css) : void 0;
+    const cssText = has9(files.css) ? readText(files.css) : void 0;
     const rules = cssText === void 0 ? [] : parseComponentCss(cssText, docs?.anatomy ?? {}, describeVar);
     const used = [...new Set(rules.flatMap((r) => r.vars.map((v) => v.name)))].sort();
-    const storiesText = has8(files.stories) ? readText(files.stories) : void 0;
+    const storiesText = has9(files.stories) ? readText(files.stories) : void 0;
     return {
       name,
       slug: componentSlug(name),
@@ -5459,6 +6562,389 @@ function snapshotLlmsTxt(model, snapshot) {
 `;
 }
 
+// ../core/src/activity.ts
+var ACTIVITY_SCHEMA_VERSION = 1;
+var ACTIVITY_FILE = "activity.json";
+var ACTIVITY_MAX_BYTES = 3e6;
+var ACTIVITY_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var ACTIVITY_LIMITS = {
+  /** Open pull requests recorded in full (the page of each; the list carries every open one). */
+  branches: 30,
+  /** Open suggestions read with their comments (parsed payload, counted approvals). */
+  suggestions: 30,
+  /** Request issues listed (open and closed); open ones are read with their comments. */
+  requests: 30,
+  /** Merged pull requests summarized. */
+  merged: 20,
+  /** Token history entries (core loadGitHubHistory limit). */
+  history: 20,
+  /** History entries whose two commits' file lists are recorded, so their before/after opens without the API. */
+  historyTrees: 10
+};
+var ActivityError = class extends Error {
+};
+var isObj3 = (x) => !!x && typeof x === "object" && !Array.isArray(x);
+var API2 = "https://api.github.com";
+function activityKey(url) {
+  let u;
+  try {
+    u = new URL(url, API2);
+  } catch {
+    return null;
+  }
+  if (u.origin !== API2) return null;
+  const parts = u.pathname.split("/");
+  if (parts[1] === "repos" && parts.length > 3) {
+    parts[2] = parts[2].toLowerCase();
+    parts[3] = parts[3].toLowerCase();
+  } else if (parts[1] === "users" && parts.length > 2) parts[2] = parts[2].toLowerCase();
+  const q = [...u.searchParams].sort(([a, av], [b, bv]) => a === b ? av < bv ? -1 : 1 : a < b ? -1 : 1);
+  const search = q.length ? `?${new URLSearchParams(q).toString()}` : "";
+  return parts.join("/") + search;
+}
+var KEPT_URLS = /* @__PURE__ */ new Set(["html_url", "avatar_url", "target_url", "details_url", "environment_url", "raw_url"]);
+var DROPPED = /* @__PURE__ */ new Set(["_links", "patch", "body_html", "body_text", "reactions", "performed_via_github_app", "node_id", "gravatar_id", "user_view_type", "site_admin", "event", "sub_issues_summary", "issue_dependencies_summary", "pull_request_review_id"]);
+var LONG_TEXT = 6e4;
+var trimUser = (u) => ({
+  login: u.login,
+  ...u.id !== void 0 ? { id: u.id } : {},
+  ...u.avatar_url ? { avatar_url: u.avatar_url } : {},
+  ...u.html_url ? { html_url: u.html_url } : {},
+  ...u.type ? { type: u.type } : {}
+});
+var trimRepo = (r) => ({
+  ...r.id !== void 0 ? { id: r.id } : {},
+  name: r.name,
+  full_name: r.full_name,
+  ...r.private !== void 0 ? { private: r.private } : {},
+  ...r.fork !== void 0 ? { fork: r.fork } : {},
+  ...r.default_branch ? { default_branch: r.default_branch } : {},
+  ...isObj3(r.owner) ? { owner: trimUser(r.owner) } : {},
+  ...r.html_url ? { html_url: r.html_url } : {}
+});
+function trimGitHub(value, key = "") {
+  if (typeof value === "string") return value.length > LONG_TEXT ? value.slice(0, LONG_TEXT) : value;
+  if (Array.isArray(value)) return value.map((v) => trimGitHub(v, key));
+  if (!isObj3(value)) return value;
+  if (key === "tree" && typeof value.path === "string" && typeof value.type === "string") return { path: value.path, type: value.type, sha: value.sha, ...value.mode ? { mode: value.mode } : {} };
+  if ((key === "repo" || key === "repository" || key === "head_repository") && typeof value.full_name === "string") return trimRepo(value);
+  if (typeof value.login === "string" && ("avatar_url" in value || "type" in value)) return trimUser(value);
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (DROPPED.has(k)) continue;
+    if ((k === "url" || k.endsWith("_url")) && !KEPT_URLS.has(k)) continue;
+    if (k === "output" && isObj3(v)) {
+      out[k] = { title: v.title ?? null, summary: typeof v.summary === "string" ? v.summary.slice(0, 2e3) : null, annotations_count: v.annotations_count ?? 0 };
+      continue;
+    }
+    if (k === "app" && isObj3(v)) {
+      out[k] = { id: v.id, slug: v.slug, name: v.name };
+      continue;
+    }
+    out[k] = trimGitHub(v, k);
+  }
+  return out;
+}
+var JSON_ACCEPT = /application\/(vnd\.github\+)?json/;
+var SKIP2 = /* @__PURE__ */ Symbol("skip");
+function activityTreeFilter(config) {
+  const under = (dir) => {
+    const d = (dir ?? "").replace(/^\.\/|\/$/g, "");
+    return d && d !== "." ? `${d}/` : "";
+  };
+  const tokens2 = under(config.tokens.root);
+  const changesets = config.changesets ? under(config.changesets.dir) : null;
+  const pkg = new Set(packageDirCandidates(config).flatMap((d) => [d ? `${d}/CHANGELOG.md` : "CHANGELOG.md", d ? `${d}/package.json` : "package.json"]));
+  return (p) => p === "bridge.config.json" || pkg.has(p) || (tokens2 ? p.startsWith(tokens2) : p.endsWith(".json")) || changesets !== null && changesets !== "" && p.startsWith(changesets);
+}
+var UNREAD = [/\/git\/blobs\//, /\/commits\/[^/]+\/pulls$/, /\/commits\?/, /\/tags\?/, /\/contents\//];
+function activityShaper(config) {
+  const keep = activityTreeFilter(config);
+  return (key, body) => {
+    if (UNREAD.some((r) => r.test(key))) return SKIP2;
+    if (key.includes("/git/trees/") && isObj3(body) && Array.isArray(body.tree)) return { sha: body.sha, tree: body.tree.filter((e) => keep(e.path)), truncated: Boolean(body.truncated) };
+    if (key.includes("/compare/") && isObj3(body)) {
+      const c = body;
+      return {
+        status: c.status,
+        ahead_by: c.ahead_by,
+        behind_by: c.behind_by,
+        total_commits: c.total_commits,
+        merge_base_commit: c.merge_base_commit ? { sha: c.merge_base_commit.sha } : null,
+        base_commit: c.base_commit ? { sha: c.base_commit.sha, commit: { tree: { sha: c.base_commit.commit?.tree?.sha } } } : null,
+        files: Array.isArray(c.files) ? c.files.map((f) => ({ filename: f.filename, status: f.status, ...f.previous_filename ? { previous_filename: f.previous_filename } : {}, sha: f.sha, additions: f.additions, deletions: f.deletions, changes: f.changes })) : []
+      };
+    }
+    return body;
+  };
+}
+var HISTORY_MAX_CHANGES = 100;
+function capHistory(report, max = HISTORY_MAX_CHANGES) {
+  return {
+    ...report,
+    entries: report.entries.map((e) => e.changes.length > max || (e.reasons?.length ?? 0) > max ? { ...e, changes: e.changes.slice(0, max), ...e.reasons ? { reasons: e.reasons.slice(0, max) } : {} } : e)
+  };
+}
+function recordingFetch(fetchImpl, into, shape = (_k, b) => b) {
+  return async (url, init2) => {
+    const res = await fetchImpl(url, init2);
+    const method = (init2?.method ?? "GET").toUpperCase();
+    const accept = init2?.headers?.Accept ?? init2?.headers?.accept ?? "application/vnd.github+json";
+    const key = activityKey(url);
+    if (method !== "GET" || !key || !JSON_ACCEPT.test(accept) || res.status !== 200 && res.status !== 404) return res;
+    const text = await res.text();
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      return { ok: res.ok, status: res.status, headers: res.headers, json: async () => JSON.parse(text), text: async () => text };
+    }
+    const shaped = shape(key, trimGitHub(body));
+    if (shaped !== SKIP2) into.set(key, { status: res.status, body: shaped });
+    return { ok: res.ok, status: res.status, ...res.headers ? { headers: res.headers } : {}, json: async () => JSON.parse(text), text: async () => text };
+  };
+}
+var labelObjs = (labels) => labelNames(labels).map((name) => ({ name }));
+function labelNames(labels) {
+  return (labels ?? []).map((l) => typeof l === "string" ? l : l.name ?? "").filter(Boolean);
+}
+var byUpdated = (a, b) => a.updated_at < b.updated_at ? 1 : a.updated_at > b.updated_at ? -1 : 0;
+async function collectActivity(input) {
+  const limits = { ...ACTIVITY_LIMITS, ...input.limits };
+  const responses = /* @__PURE__ */ new Map();
+  const rec = recordingFetch(input.fetch, responses, activityShaper(input.config));
+  const client = new GitHubClient(`${input.owner}/${input.repo}`, input.token, rec, { attempts: 2, baseDelayMs: 500, sleep: (ms) => new Promise((r) => setTimeout(r, ms)) }, { etags: false });
+  const R = `/repos/${input.owner}/${input.repo}`;
+  const problems = [];
+  const truncated = [];
+  let limited = false;
+  const headers = { Accept: "application/vnd.github+json", "X-GitHub-Api-Version": "2022-11-28", ...input.token ? { Authorization: `Bearer ${input.token}` } : {} };
+  const get = async (path) => {
+    if (limited) return void 0;
+    try {
+      const res = await rec(`${API2}${path}`, { headers });
+      if (res.status === 404) return void 0;
+      if (!res.ok) {
+        if ((res.status === 403 || res.status === 429) && res.headers?.get("x-ratelimit-remaining") === "0") {
+          limited = true;
+          problems.push("GitHub hourly limit reached while reading activity: the rest was left out.");
+        } else problems.push(`GitHub answered ${res.status} for ${path}`);
+        return void 0;
+      }
+      return await res.json();
+    } catch (err) {
+      problems.push(`Could not read ${path}: ${err.message}`);
+      return void 0;
+    }
+  };
+  const safely = async (what, fn, fallback) => {
+    if (limited) return fallback;
+    try {
+      return await fn();
+    } catch (err) {
+      const msg = err.message;
+      if (/limit/i.test(msg) && err.status === 429) limited = true;
+      problems.push(`${what}: ${msg}`);
+      return fallback;
+    }
+  };
+  const info = await safely("Repository", () => client.getRepo(), null);
+  const branch = info?.defaultBranch ?? input.config.repo?.defaultBranch ?? "main";
+  const headSha = await safely("Default branch", () => client.getBranchSha(branch), void 0) ?? "";
+  const open = await get(`${R}/pulls?state=open&per_page=100`) ?? [];
+  const closed = await get(`${R}/pulls?state=closed&sort=updated&direction=desc&per_page=30`) ?? [];
+  await get(`${R}/pulls?state=closed&per_page=50&sort=updated&direction=desc`);
+  await get(`${R}/rules/branches/${encodeURIComponent(branch)}`);
+  await get(`${R}/git/matching-refs/heads/bridge-visual`);
+  await safely("Owner account", () => client.getAccountType(input.owner), null);
+  const prev = input.previous ?? null;
+  const sameRepoPrev = Boolean(prev && sameRepo(prev, input));
+  const prevOk = sameRepoPrev && Boolean(headSha) && prev.headSha === headSha;
+  const kept = async (path, reuse) => {
+    const key = reuse ? activityKey(`${API2}${path}`) : null;
+    const hit = key ? prev.responses[key] : void 0;
+    if (key && hit) {
+      responses.set(key, hit);
+      return hit.status === 200 ? hit.body : void 0;
+    }
+    return get(path);
+  };
+  const branches4 = [];
+  const sorted = [...open].sort(byUpdated);
+  if (sorted.length > limits.branches) truncated.push(`${sorted.length - limits.branches} open branches beyond the ${limits.branches} most recently updated are listed without their pages.`);
+  for (const [i, p] of sorted.entries()) {
+    const full = i < limits.branches;
+    const base = {
+      number: p.number,
+      title: p.title,
+      author: p.user?.login ?? "",
+      url: p.html_url,
+      branch: p.head.ref,
+      base: p.base.ref,
+      headSha: p.head.sha,
+      baseSha: p.base.sha,
+      state: p.draft ? "draft" : "open",
+      labels: labelNames(p.labels),
+      tier: effectiveTier(labelObjs(p.labels), p.body ?? null, null),
+      createdAt: p.created_at,
+      updatedAt: p.updated_at,
+      comments: null,
+      files: null,
+      previews: [],
+      checks: null
+    };
+    if (!full || limited) {
+      branches4.push(base);
+      continue;
+    }
+    const n = p.number;
+    const was = prevOk ? prev.branches.find((b) => b.number === n) : void 0;
+    const same2 = Boolean(was && was.updatedAt === p.updated_at && was.headSha === p.head.sha && was.comments !== null);
+    const [pull, files, , , , , status] = await Promise.all([
+      kept(`${R}/pulls/${n}`, same2),
+      kept(`${R}/pulls/${n}/files?per_page=100`, same2),
+      kept(`${R}/pulls/${n}/reviews?per_page=100`, same2),
+      kept(`${R}/issues/${n}/comments?per_page=100`, same2),
+      kept(`${R}/pulls/${n}/comments?per_page=100`, same2),
+      get(`${R}/commits/${p.head.sha}/check-runs?per_page=100`),
+      get(`${R}/commits/${p.head.sha}/status`),
+      kept(`${R}/compare/${encodeURIComponent(p.base.ref)}...${p.head.sha}`, same2),
+      kept(`${R}/git/trees/${p.base.sha}?recursive=1`, sameRepoPrev),
+      kept(`${R}/git/trees/${p.head.sha}?recursive=1`, sameRepoPrev),
+      kept(`${R}/issues/${n}/labels`, same2)
+    ]);
+    const root = input.config.tokens.root.replace(/\/$/, "");
+    branches4.push({
+      ...base,
+      tier: effectiveTier(labelObjs((pull ?? p).labels), (pull ?? p).body ?? null, files ?? null),
+      comments: pull ? (pull.comments ?? 0) + (pull.review_comments ?? 0) : null,
+      files: files ? { changed: files.length, tokens: files.map((f) => f.filename).filter((f) => f.startsWith(`${root}/`) && f.endsWith(".json")) } : null,
+      previews: (status?.statuses ?? []).filter((s) => s.state === "success" && s.target_url && /^https:\/\//.test(s.target_url)).map((s) => ({ context: s.context, url: s.target_url })),
+      checks: status ? status.state === "success" || status.state === "failure" || status.state === "pending" ? status.state : "none" : null
+    });
+  }
+  const gov = { owners: input.config.governance.owners, rights: input.config.governance.rights, soloOwnerCanApproveBoth: input.config.governance.soloOwnerCanApproveBoth };
+  const items = await safely("Suggestions", () => listSuggestionsOnGitHub(client, { state: "open" }), []);
+  const pullsAll = items.length ? await safely("Pull requests", () => client.listPullRequests("all"), []) : [];
+  if (items.length > limits.suggestions) truncated.push(`${items.length - limits.suggestions} open suggestions beyond the ${limits.suggestions} newest are listed without their pages.`);
+  const suggestions2 = [];
+  for (const [i, s] of items.entries()) {
+    const d = i < limits.suggestions ? await safely(`Suggestion #${s.number}`, () => getSuggestionOnGitHub(client, s.number, gov, { pulls: pullsAll }), null) : null;
+    suggestions2.push({
+      number: s.number,
+      title: s.title,
+      author: s.author,
+      url: s.url,
+      createdAt: s.createdAt,
+      kind: s.kind ?? null,
+      status: d?.status ?? s.status,
+      labels: s.labels,
+      comments: d ? d.comments.length : null,
+      payload: d?.parsed.ok ? d.parsed.payload : null,
+      approvers: d?.approvals?.approvers ?? []
+    });
+  }
+  const issues = await safely("Requests", () => client.listIssues({ label: REQUEST_LABEL, state: "all", perPage: 50 }), []);
+  const requests3 = [];
+  const openIssues = issues.filter((i) => i.state === "open");
+  if (openIssues.length > limits.requests) truncated.push(`${openIssues.length - limits.requests} open requests beyond the ${limits.requests} newest are listed without their pages.`);
+  for (const [i, r] of issues.slice(0, Math.max(limits.requests, 0)).entries()) {
+    if (r.state === "open" && i < limits.requests) {
+      await get(`${R}/issues/${r.number}`);
+      await get(`${R}/issues/${r.number}/comments?per_page=100`);
+    }
+    const parsed = parseRequestIssue(r.body);
+    const linked = [...open, ...closed].filter((p) => new RegExp(`(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\\s+#${r.number}\\b`, "i").test(p.body ?? ""));
+    requests3.push({
+      number: r.number,
+      title: r.title,
+      author: r.author,
+      url: r.url,
+      state: r.state,
+      status: requestStatus({ state: r.state, stateReason: r.stateReason, linkedPrs: linked.map((p) => ({ state: p.state === "open" ? "open" : "closed", merged: Boolean(p.merged_at) })) }),
+      kind: parsed?.kind ?? null,
+      component: parsed?.component ?? null,
+      labels: r.labels,
+      createdAt: r.createdAt
+    });
+  }
+  const merged = closed.filter((p) => p.merged_at).slice(0, limits.merged).map((p) => ({ number: p.number, title: p.title, author: p.user?.login ?? "", url: p.html_url, mergedAt: p.merged_at, labels: labelNames(p.labels), tier: effectiveTier(labelObjs(p.labels), p.body ?? null, null) }));
+  let history = null;
+  if (prevOk && prev.history) {
+    history = prev.history;
+    for (const [k, v] of Object.entries(prev.responses)) if (isHistoryKey(k) && !responses.has(k)) responses.set(k, v);
+  } else if (!limited && headSha) {
+    const read = await safely("Token history", () => loadGitHubHistory(client, input.config, { ref: branch, limit: limits.history }), null);
+    history = read && capHistory(read);
+    if (history) {
+      const backend = gitHubHistoryBackend(client, input.config, { concurrency: 2 });
+      const shas = [...new Set(history.entries.filter((e) => !e.bulk).slice(0, limits.historyTrees).flatMap((e) => [e.sha, ...e.baseSha ? [e.baseSha] : []]))];
+      for (const sha of shas) await safely(`Files at ${sha.slice(0, 7)}`, () => backend.tree(sha), []);
+    }
+  }
+  const activity = {
+    kind: "bridge-activity",
+    schemaVersion: ACTIVITY_SCHEMA_VERSION,
+    tool: { name: "bridge", version: input.version },
+    generatedAt: input.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    repo: { owner: input.owner, name: input.repo, branch },
+    headSha,
+    branches: branches4,
+    suggestions: suggestions2,
+    requests: requests3,
+    merged,
+    history,
+    responses: Object.fromEntries([...responses].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)),
+    truncated,
+    problems
+  };
+  return fitActivity(activity);
+}
+var sameRepo = (a, b) => a.repo.owner.toLowerCase() === b.owner.toLowerCase() && a.repo.name.toLowerCase() === b.repo.toLowerCase();
+var isHistoryKey = (k) => /\/git\/commits\/[0-9a-f]+$/.test(k) || /\/git\/trees\/[0-9a-f]+\?recursive=1$/.test(k);
+var activityBytes = (a) => new TextEncoder().encode(`${JSON.stringify(a)}
+`).length;
+function fitActivity(activity, max = ACTIVITY_MAX_BYTES) {
+  if (activityBytes(activity) <= max) return activity;
+  const out = { ...activity, responses: { ...activity.responses }, truncated: [...activity.truncated] };
+  const drop = (test) => {
+    for (const k of Object.keys(out.responses)) if (test(k)) delete out.responses[k];
+  };
+  drop((k) => k.includes("/git/trees/"));
+  out.truncated.push("File lists were left out to keep activity.json small: a branch or history change reads them from GitHub.");
+  if (activityBytes(out) <= max) return out;
+  const old = [...out.branches].sort((a, b) => a.updatedAt < b.updatedAt ? -1 : 1);
+  for (const b of old) {
+    drop((k) => new RegExp(`/(pulls|issues)/${b.number}(/|$|\\?)`).test(k) || k.includes(`/commits/${b.headSha}/`) || k.includes(`...${b.headSha}`));
+    if (activityBytes(out) <= max) {
+      out.truncated.push("The pages of the least recently updated branches were left out: they read from GitHub.");
+      return out;
+    }
+  }
+  out.responses = {};
+  out.truncated.push("Every recorded read was left out: pages read GitHub live.");
+  return out;
+}
+function parseActivity(input) {
+  let data = input;
+  if (typeof input === "string") {
+    try {
+      data = JSON.parse(input);
+    } catch (err) {
+      throw new ActivityError(`${ACTIVITY_FILE} is not valid JSON (${err.message})`);
+    }
+  }
+  if (!isObj3(data) || data.kind !== "bridge-activity") throw new ActivityError(`${ACTIVITY_FILE} is not a Bridge activity file`);
+  if (data.schemaVersion !== ACTIVITY_SCHEMA_VERSION) throw new ActivityError(`${ACTIVITY_FILE} is schema version ${String(data.schemaVersion)}; this version of Bridge reads ${ACTIVITY_SCHEMA_VERSION}`);
+  const repo = data.repo;
+  if (!isObj3(repo) || typeof repo.owner !== "string" || typeof repo.name !== "string" || typeof repo.branch !== "string") throw new ActivityError(`${ACTIVITY_FILE}: repo needs owner, name and branch`);
+  if (typeof data.generatedAt !== "string" || Number.isNaN(Date.parse(data.generatedAt))) throw new ActivityError(`${ACTIVITY_FILE}: generatedAt is missing`);
+  for (const k of ["branches", "suggestions", "requests", "merged", "truncated", "problems"]) if (!Array.isArray(data[k])) throw new ActivityError(`${ACTIVITY_FILE}: ${k} must be a list`);
+  if (!isObj3(data.responses) || !Object.values(data.responses).every((r) => isObj3(r) && typeof r.status === "number")) throw new ActivityError(`${ACTIVITY_FILE}: responses must map paths to { status, body }`);
+  if (data.history !== null && !(isObj3(data.history) && Array.isArray(data.history.entries))) throw new ActivityError(`${ACTIVITY_FILE}: history must be null or a history report`);
+  return data;
+}
+
 // ../visual/src/capture.ts
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname as dirname2 } from "node:path";
@@ -5859,17 +7345,17 @@ var shotKey = (...parts) => parts.map((p) => p.toLowerCase().replace(/[^a-z0-9-]
 
 // ../visual/src/select.ts
 var NO_VISUAL = /(\.test\.[cm]?[jt]sx?|\.spec\.[cm]?[jt]sx?|\.docs\.json|\.mdx?|README[^/]*)$/i;
-var norm3 = (p) => p.replace(/^\.\//, "").replace(/\\/g, "/");
+var norm5 = (p) => p.replace(/^\.\//, "").replace(/\\/g, "/");
 var isAllStates = (s) => /--all-states$/.test(s.id) || /^all ?states$/i.test(s.name);
 function storyComponent(s, componentsDir) {
-  return componentForPath(norm3(s.importPath), componentsDir);
+  return componentForPath(norm5(s.importPath), componentsDir);
 }
 function selectImpact(input) {
   const { usage, stories } = input;
   const dir = usage.componentsDir;
   const lib = input.librarySrc.replace(/\/$/, "");
   const cap = input.maxStoriesPerComponent ?? 4;
-  const visualFiles = input.files.map(norm3).filter((f) => !NO_VISUAL.test(f));
+  const visualFiles = input.files.map(norm5).filter((f) => !NO_VISUAL.test(f));
   const vars = [...new Set(input.tokens.map((t) => input.cssVar(t.path)))].sort();
   const impact2 = impactedModules(usage, { vars, files: visualFiles });
   let fallback = null;
@@ -5909,7 +7395,7 @@ function selectImpact(input) {
   return {
     tokens: input.tokens,
     vars,
-    files: input.files.map(norm3),
+    files: input.files.map(norm5),
     components: components.map((c) => ({ id: c.id, reasons: c.reasons, indirect: c.indirect })),
     stories: [...new Set(picked)],
     fallback,
@@ -5928,7 +7414,7 @@ function storiesFromSource(files) {
     if (!title) continue;
     for (const m of f.text.matchAll(/export\s+const\s+([A-Z]\w*)\s*[:=]/g)) {
       const name = m[1];
-      out.push({ id: storyId(title, name), title, name: name.replace(/([a-z0-9])([A-Z])/g, "$1 $2"), importPath: `./${norm3(f.path)}` });
+      out.push({ id: storyId(title, name), title, name: name.replace(/([a-z0-9])([A-Z])/g, "$1 $2"), importPath: `./${norm5(f.path)}` });
     }
   }
   return out;
@@ -6556,7 +8042,7 @@ async function jiraSync(input) {
     log(`Bridge Jira sync: ${reason}`);
     return { status: "skipped", reason };
   };
-  const fail = (reason) => {
+  const fail2 = (reason) => {
     log(`::error::Bridge Jira sync: ${reason}`);
     return { status: "error", reason };
   };
@@ -6571,7 +8057,7 @@ async function jiraSync(input) {
   if (!n || !repo) return skip("not an issues event.");
   if (!["opened", "labeled", "closed"].includes(action)) return skip(`nothing to do on "${action}".`);
   if (action === "labeled" && event.label?.name !== REQUEST_LABEL) return skip(`label "${event.label?.name ?? ""}" is not ${REQUEST_LABEL}.`);
-  if (!env.GITHUB_TOKEN) return fail("GITHUB_TOKEN is missing: pass secrets.GITHUB_TOKEN to the step.");
+  if (!env.GITHUB_TOKEN) return fail2("GITHUB_TOKEN is missing: pass secrets.GITHUB_TOKEN to the step.");
   const ghFetch = (url2, init2) => f(url2, init2);
   const gh = new GitHubClient(repo, env.GITHUB_TOKEN, ghFetch);
   const issue = await gh.getIssue(n);
@@ -6600,14 +8086,14 @@ async function jiraSync(input) {
     const text = `Closed in GitHub (#${n}), ${outcome}`;
     const body = { body: { type: "doc", version: 1, content: [{ type: "paragraph", content: [{ type: "text", text, marks: [{ type: "link", attrs: { href: issue.url } }] }] }] } };
     const res2 = await f(`${base}/rest/api/3/issue/${encodeURIComponent(key)}/comment`, { method: "POST", headers, body: JSON.stringify(body) });
-    if (!res2.ok) return fail(await jiraError(res2));
+    if (!res2.ok) return fail2(await jiraError(res2));
     log(`Bridge Jira sync: commented on ${key}: ${text}.`);
     return { status: "commented", key };
   }
   if (key) return skip(`#${n} is already linked to ${key}.`);
   const request = requests.requestFromIssue(issue);
   const res = await f(`${base}/rest/api/3/issue`, { method: "POST", headers, body: JSON.stringify({ fields: jiraIssueFields(request, jira, issue.url) }) });
-  if (!res.ok) return fail(await jiraError(res));
+  if (!res.ok) return fail2(await jiraError(res));
   const created = await res.json();
   const url = `${base}/browse/${created.key}`;
   await gh.addComment(n, `Jira: ${created.key} ${url}`);
@@ -6637,7 +8123,7 @@ Exit codes: 0 ok, 1 not a request or Claude Code not found, 2 usage or setup err
 var RequestUsageError = class extends Error {
 };
 var flag = (a, k) => a.flags[k]?.[a.flags[k].length - 1];
-var has = (a, k) => Boolean(a.flags[k]);
+var has2 = (a, k) => Boolean(a.flags[k]);
 var defaultIO = () => ({
   print: (s) => process.stdout.write(`${s}
 `),
@@ -6697,9 +8183,9 @@ async function getOrExplain(ctx, n, io, branch) {
 }
 async function runRequest(a, root, io = defaultIO()) {
   const sub = a._[1];
-  if (!sub || sub === "help" || has(a, "help")) {
+  if (!sub || sub === "help" || has2(a, "help")) {
     io.print(REQUEST_HELP);
-    return sub || has(a, "help") ? 0 : 2;
+    return sub || has2(a, "help") ? 0 : 2;
   }
   switch (sub) {
     case "list": {
@@ -6708,7 +8194,7 @@ async function runRequest(a, root, io = defaultIO()) {
       const ctx = await context(root, io, false);
       const component = flag(a, "component");
       const r = await requests2.listRequests(ctx, { status, ...component ? { component } : {} });
-      if (has(a, "json")) return io.print(JSON.stringify(r, null, 2)), 0;
+      if (has2(a, "json")) return io.print(JSON.stringify(r, null, 2)), 0;
       if (!r.requests.length) return io.print(`No ${status === "all" ? "" : `${status} `}component change request in ${r.repo}${component ? ` for ${component}` : ""}.`), 0;
       const w = Math.max(...r.requests.map((x) => x.component.length));
       for (const x of r.requests) {
@@ -6722,7 +8208,7 @@ async function runRequest(a, root, io = defaultIO()) {
       const ctx = await context(root, io, false);
       const r = await getOrExplain(ctx, n, io);
       if (!r) return 1;
-      if (has(a, "json")) return io.print(JSON.stringify(r, null, 2)), 0;
+      if (has2(a, "json")) return io.print(JSON.stringify(r, null, 2)), 0;
       const q = r.request;
       io.print(`#${r.number} ${q.component}: ${q.title}`);
       io.print(`${REQUEST_STATUS_LABEL[r.status]}, ${q.kind}, from ${q.source}${q.requestedBy ? ` by @${q.requestedBy}` : ""}`);
@@ -6752,7 +8238,7 @@ Next: bridge request implement ${r.number} --claude`);
       const branch = flag(a, "branch");
       const r = await getOrExplain(ctx, n, io, branch);
       if (!r) return 1;
-      if (!has(a, "claude")) return io.print(r.brief), 0;
+      if (!has2(a, "claude")) return io.print(r.brief), 0;
       if (!io.hasClaude()) {
         io.print(r.brief);
         io.error(`
@@ -6770,7 +8256,7 @@ Claude Code is not installed (no \`claude\` on PATH). Install it (npm install -g
       const usage = 'bridge request create --component Button --kind new-variant --title "Add a danger ghost variant" --summary "..."';
       if (!component || !kind || !title || !summary) throw new RequestUsageError(`Usage: ${usage}`);
       if (!REQUEST_KINDS.some((k) => k.value === kind)) throw new RequestUsageError(`--kind takes ${REQUEST_KINDS.map((k) => k.value).join(", ")}, got "${kind}"`);
-      const dryRun = has(a, "dry-run");
+      const dryRun = has2(a, "dry-run");
       const ctx = await context(root, io, !dryRun);
       const figma2 = flag(a, "figma");
       const exploration = flag(a, "exploration");
@@ -6786,7 +8272,7 @@ Claude Code is not installed (no \`claude\` on PATH). Install it (npm install -g
         source: "cli",
         dryRun
       });
-      if (has(a, "json")) return io.print(JSON.stringify(r, null, 2)), 0;
+      if (has2(a, "json")) return io.print(JSON.stringify(r, null, 2)), 0;
       if (r.status === "dry-run") {
         io.print(`Dry run, nothing created.
 
@@ -6845,7 +8331,7 @@ Work on one: git switch explore/<name>, then \`bridge propose --branch explore/<
 GitHub token: GITHUB_TOKEN or BRIDGE_GITHUB_TOKEN, else \`gh auth token\`.
 Exit codes: 0 ok, 2 usage or setup error.`;
 var flag2 = (a, k) => a.flags[k]?.[a.flags[k].length - 1];
-var has2 = (a, k) => Boolean(a.flags[k]);
+var has3 = (a, k) => Boolean(a.flags[k]);
 async function context2(root, io) {
   const token = io.env.BRIDGE_GITHUB_TOKEN || io.env.GITHUB_TOKEN || io.ghToken();
   return BridgeContext3.create({ root, ...token ? { token } : {}, ...io.fetch ? { fetch: io.fetch } : {} });
@@ -6854,11 +8340,11 @@ var exploreSource = (env) => ({ source: "cli", ...env.CLAUDECODE ? { agent: "cla
 var date = (iso) => iso ? iso.slice(0, 10) : "";
 async function runExplore(a, root, io = defaultIO()) {
   const sub = a._[1];
-  if (!sub || sub === "help" || has2(a, "help")) {
+  if (!sub || sub === "help" || has3(a, "help")) {
     io.print(EXPLORE_HELP);
-    return sub || has2(a, "help") ? 0 : 2;
+    return sub || has3(a, "help") ? 0 : 2;
   }
-  const json = has2(a, "json");
+  const json = has3(a, "json");
   switch (sub) {
     case "start": {
       const name = a._.slice(2).join(" ").trim() || flag2(a, "name");
@@ -6866,7 +8352,7 @@ async function runExplore(a, root, io = defaultIO()) {
       if (!name || !purpose) throw new RequestUsageError('Usage: bridge explore start <name> --purpose "What you want to learn"');
       const useCase = flag2(a, "use-case");
       const ctx = await context2(root, io);
-      const r = await explorations.startExploration(ctx, { name, purpose, ...exploreSource(io.env), ...useCase ? { useCase } : {}, ...a.flags.experimental ? { experimental: a.flags.experimental } : {}, ...flag2(a, "product") ? { product: flag2(a, "product") } : {}, dryRun: has2(a, "dry-run") });
+      const r = await explorations.startExploration(ctx, { name, purpose, ...exploreSource(io.env), ...useCase ? { useCase } : {}, ...a.flags.experimental ? { experimental: a.flags.experimental } : {}, ...flag2(a, "product") ? { product: flag2(a, "product") } : {}, dryRun: has3(a, "dry-run") });
       if (json) return io.print(JSON.stringify(r, null, 2)), 0;
       if (r.status === "dry-run") {
         io.print(`Dry run, nothing written.
@@ -6890,7 +8376,7 @@ Next: ${r.next}`);
     }
     case "list": {
       const ctx = await context2(root, io);
-      const r = await explorations.listExplorations(ctx, { state: has2(a, "all") ? "all" : "open" });
+      const r = await explorations.listExplorations(ctx, { state: has3(a, "all") ? "all" : "open" });
       if (json) return io.print(JSON.stringify(r, null, 2)), 0;
       io.print(r.summary);
       for (const x of r.explorations) {
@@ -6911,7 +8397,7 @@ Local only: ${b} (push it and open a draft pull request labeled exploration)`);
       const ref = a._.slice(2).join(" ").trim();
       if (!ref) throw new RequestUsageError("Usage: bridge explore promote <name|#pr> [--dry-run]");
       const ctx = await context2(root, io);
-      const r = await explorations.promoteExploration(ctx, { ref, dryRun: has2(a, "dry-run") });
+      const r = await explorations.promoteExploration(ctx, { ref, dryRun: has3(a, "dry-run") });
       if (json) return io.print(JSON.stringify(r, null, 2)), 0;
       io.print(`${r.status === "dry-run" ? "Dry run: would promote" : "Promoted"} #${r.number} "${r.title}" to review: Tier ${r.tier}.`);
       io.print(`Labels: +${r.addLabels.join(", +")}, -${r.removeLabels.join(", -")}${r.removeFiles.length ? `. Removes ${r.removeFiles.join(", ")}` : ""}.`);
@@ -6965,10 +8451,10 @@ GitHub token: GITHUB_TOKEN or BRIDGE_GITHUB_TOKEN, else \`gh auth token\`. Readi
 Exit codes (apply): 0 applied, already applied or a clean dry run; 1 not approved, blocked by a check or refused;
 2 usage or setup error; 3 conflict with today's code.`;
 var flag3 = (a, k) => a.flags[k]?.[a.flags[k].length - 1];
-var has3 = (a, k) => Boolean(a.flags[k]);
+var has4 = (a, k) => Boolean(a.flags[k]);
 function changesFlag(a) {
-  if (has3(a, "suggest") && has3(a, "direct")) throw new SuggestUsageError("Pass --suggest or --direct, not both.");
-  return has3(a, "direct") ? "direct" : has3(a, "suggest") ? "suggest" : void 0;
+  if (has4(a, "suggest") && has4(a, "direct")) throw new SuggestUsageError("Pass --suggest or --direct, not both.");
+  return has4(a, "direct") ? "direct" : has4(a, "suggest") ? "suggest" : void 0;
 }
 function tokenFrom2(io) {
   return io.env.BRIDGE_GITHUB_TOKEN || io.env.GITHUB_TOKEN || io.ghToken();
@@ -6986,7 +8472,7 @@ var STATUSES = ["needs-review", "changes-requested", "approved", "applying", "ap
 var KINDS = ["token-change", "docs", "component-spec", "brand", "revert", "config"];
 async function runSuggestions(a, root, io = defaultIO()) {
   const sub = a._[1] ?? "list";
-  if (sub === "help" || has3(a, "help")) return io.print(SUGGESTIONS_HELP), 0;
+  if (sub === "help" || has4(a, "help")) return io.print(SUGGESTIONS_HELP), 0;
   switch (sub) {
     case "list": {
       const status = flag3(a, "status") ?? "all";
@@ -6995,7 +8481,7 @@ async function runSuggestions(a, root, io = defaultIO()) {
       if (kind && !KINDS.includes(kind)) throw new SuggestUsageError(`--kind takes ${KINDS.join(", ")}, got "${kind}"`);
       const ctx = await context3(root, io);
       const r = await suggestions.listSuggestionsOp(ctx, { status, ...kind ? { kind } : {} });
-      if (has3(a, "json")) return io.print(JSON.stringify(r, null, 2)), 0;
+      if (has4(a, "json")) return io.print(JSON.stringify(r, null, 2)), 0;
       if (!r.suggestions.length) return io.print(`No ${status === "all" ? "open " : `${status} `}suggestion in ${r.repo}.`), 0;
       for (const x of r.suggestions) {
         const prs = x.linkedPrs.length ? `  PR ${x.linkedPrs.map((p) => `#${p.number}${p.merged ? " merged" : ` ${p.state}`}`).join(", ")}` : "";
@@ -7009,7 +8495,7 @@ ${r.next}`);
       const n = issueNumber2(a._[2], "bridge suggestions show <number>");
       const ctx = await context3(root, io);
       const r = await suggestions.getSuggestionOp(ctx, { number: n });
-      if (has3(a, "json")) return io.print(JSON.stringify(r, null, 2)), 0;
+      if (has4(a, "json")) return io.print(JSON.stringify(r, null, 2)), 0;
       io.print(`#${r.number} ${r.title}`);
       io.print(`${r.said}${r.kind ? `, ${r.kind}` : ""}${r.tier ? `, tier ${r.tier} (${r.bump})` : ""}${r.source ? `, from ${r.source}` : ""}${r.suggestedBy ? ` by @${r.suggestedBy}` : ""}`);
       io.print(r.url);
@@ -7047,7 +8533,7 @@ Next: ${r.next}`);
       if (!pr && !branch) throw new SuggestUsageError("Usage: bridge suggestions link <number> --pr <m> (or --branch <name>)");
       const ctx = await context3(root, io);
       const r = await suggestions.linkSuggestionOp(ctx, { number: n, ...pr ? { pr } : {}, ...branch ? { branch } : {} });
-      if (has3(a, "json")) return io.print(JSON.stringify(r, null, 2)), 0;
+      if (has4(a, "json")) return io.print(JSON.stringify(r, null, 2)), 0;
       io.print(`#${n} is being applied${pr ? ` in #${pr}` : branch ? ` on ${branch}` : ""}.`);
       for (const w of r.warnings ?? []) io.error(`warning: ${w}`);
       return 0;
@@ -7060,23 +8546,23 @@ ${SUGGESTIONS_HELP}`);
 }
 var fmt = (v) => v === void 0 ? "(none)" : typeof v === "string" ? v : JSON.stringify(v);
 async function runApply(a, root, io = defaultIO()) {
-  if (has3(a, "help") || a._[1] === "help") return io.print(SUGGESTIONS_HELP), 0;
+  if (has4(a, "help") || a._[1] === "help") return io.print(SUGGESTIONS_HELP), 0;
   const n = issueNumber2(a._[1], "bridge apply <number> [--write | --patch] [--dry-run]");
-  if (has3(a, "write") && has3(a, "patch")) throw new SuggestUsageError("Pass --write or --patch, not both.");
-  const mode2 = has3(a, "write") ? "write" : has3(a, "patch") ? "patch" : "branch";
+  if (has4(a, "write") && has4(a, "patch")) throw new SuggestUsageError("Pass --write or --patch, not both.");
+  const mode2 = has4(a, "write") ? "write" : has4(a, "patch") ? "patch" : "branch";
   const ctx = await context3(root, io);
   if (ctx.mode !== "local" || !ctx.isGit) throw new SuggestUsageError("bridge apply runs in a git checkout of the design system: cd into it, or pass --root.");
   const branch = flag3(a, "branch");
   const r = await suggestions.applySuggestionOp(ctx, {
     number: n,
-    mode: has3(a, "dry-run") ? "dry-run" : mode2,
-    acceptEdited: has3(a, "accept-edited"),
-    forceUnapproved: has3(a, "force-unapproved"),
+    mode: has4(a, "dry-run") ? "dry-run" : mode2,
+    acceptEdited: has4(a, "accept-edited"),
+    forceUnapproved: has4(a, "force-unapproved"),
     ...branch ? { branch } : {}
   });
   const code = typeof r.exitCode === "number" ? r.exitCode : SUGGESTION_APPLY_EXIT[r.outcome] ?? 1;
-  if (has3(a, "json")) return io.print(JSON.stringify(r, null, 2)), code;
-  if (mode2 === "patch" && r.patch && !has3(a, "dry-run")) {
+  if (has4(a, "json")) return io.print(JSON.stringify(r, null, 2)), code;
+  if (mode2 === "patch" && r.patch && !has4(a, "dry-run")) {
     io.print(r.patch.trimEnd());
     io.error(r.message);
     for (const w of r.warnings ?? []) io.error(`warning: ${w}`);
@@ -7100,10 +8586,10 @@ Next: ${r.next}`);
   return code;
 }
 async function runReview(a, root, io = defaultIO()) {
-  if (has3(a, "help") || a._[1] === "help") return io.print(SUGGESTIONS_HELP), 0;
+  if (has4(a, "help") || a._[1] === "help") return io.print(SUGGESTIONS_HELP), 0;
   const usage = 'bridge review <number> --approve | --request-changes --message "..." | --decline --message "..."';
   const n = issueNumber2(a._[1], usage);
-  const events = ["approve", "request-changes", "decline", "comment"].filter((e) => has3(a, e));
+  const events = ["approve", "request-changes", "decline", "comment"].filter((e) => has4(a, e));
   if (events.length !== 1) throw new SuggestUsageError(`Usage: ${usage}`);
   const event = events[0];
   const inline = flag3(a, event);
@@ -7120,7 +8606,7 @@ async function runReview(a, root, io = defaultIO()) {
     ...role ? { role } : {},
     ...version ? { payloadSha: version } : {}
   });
-  if (has3(a, "json")) return io.print(JSON.stringify(r, null, 2)), 0;
+  if (has4(a, "json")) return io.print(JSON.stringify(r, null, 2)), 0;
   const done = event === "approve" ? "Approved" : event === "request-changes" ? "Changes requested on" : event === "decline" ? "Declined" : "Commented on";
   io.print(`${done} #${n}${r.version ? ` (version ${r.version})` : ""}. Now: ${SUGGESTION_STATUS_LABEL[r.status] ?? r.status}.`);
   for (const w of r.warnings ?? []) io.error(`warning: ${w}`);
@@ -7159,7 +8645,7 @@ Usage:
 Start work for a product: bridge propose|explore start|request create ... --product <key> [--jira DS-42].
 GitHub token: GITHUB_TOKEN or BRIDGE_GITHUB_TOKEN, else \`gh auth token\`. Exit codes: 0 ok, 2 usage or setup error.`;
 var flag4 = (a, k) => a.flags[k]?.[a.flags[k].length - 1];
-var has4 = (a, k) => Boolean(a.flags[k]);
+var has5 = (a, k) => Boolean(a.flags[k]);
 async function context4(root, io) {
   const token = io.env.BRIDGE_GITHUB_TOKEN || io.env.GITHUB_TOKEN || io.ghToken();
   return BridgeContext5.create({ root, ...token ? { token } : {}, ...io.fetch ? { fetch: io.fetch } : {} });
@@ -7181,11 +8667,11 @@ function pairs2(list2, what) {
 var said = (r) => String(r.said ?? r.summary ?? r.status ?? "Done.");
 async function runBranch(a, root, io = defaultIO()) {
   const sub = a._[1];
-  if (!sub || sub === "help" || has4(a, "help")) {
+  if (!sub || sub === "help" || has5(a, "help")) {
     io.print(BRANCH_HELP);
-    return sub || has4(a, "help") ? 0 : 2;
+    return sub || has5(a, "help") ? 0 : 2;
   }
-  const json = has4(a, "json");
+  const json = has5(a, "json");
   const ctx = await context4(root, io);
   const out = (r, text) => (json ? io.print(JSON.stringify(r, null, 2)) : text(), 0);
   switch (sub) {
@@ -7203,6 +8689,7 @@ async function runBranch(a, root, io = defaultIO()) {
         io.print(`#${r.pr} ${r.title} (${r.product.name})`);
         io.print(`${r.status.label}. ${r.approvalNeeded} needed; approved by ${r.approvals.approvedBy.map((x) => `@${x}`).join(", ") || "nobody yet"}.`);
         if (r.approvals.soloOwner) io.print(r.approvals.soloOwner);
+        io.print(`${r.tests.label}.`);
         if (r.merge.blockedBy?.length) for (const x of r.merge.blockedBy) io.print(`  ${x}`);
         io.print(`Next: ${r.next}`);
         io.print(r.url);
@@ -7225,14 +8712,14 @@ async function runBranch(a, root, io = defaultIO()) {
     }
     case "review": {
       const n = number(a, 2, 'bridge branch review <n> --approve | --request-changes "..." | --comment "..."');
-      const decision = has4(a, "approve") ? "approve" : has4(a, "request-changes") ? "request_changes" : has4(a, "comment") ? "comment" : null;
+      const decision = has5(a, "approve") ? "approve" : has5(a, "request-changes") ? "request_changes" : has5(a, "comment") ? "comment" : null;
       if (!decision) throw new RequestUsageError('Say what you decide: --approve, --request-changes "what to change" or --comment "text".');
       const body = decision === "approve" ? flag4(a, "body") : flag4(a, decision === "request_changes" ? "request-changes" : "comment");
       const r = await branches.reviewBranch(ctx, { pr: n, decision, ...body && body !== "true" ? { body } : {} });
       return out(r, () => io.print(r.said));
     }
     case "ask": {
-      const r = await branches.askSomeoneElse(ctx, { pr: number(a, 2, "bridge branch ask <n>"), dryRun: has4(a, "dry-run") });
+      const r = await branches.askSomeoneElse(ctx, { pr: number(a, 2, "bridge branch ask <n>"), dryRun: has5(a, "dry-run") });
       return out(r, () => io.print(r.said));
     }
     case "comment": {
@@ -7246,7 +8733,7 @@ async function runBranch(a, root, io = defaultIO()) {
     case "merge": {
       const n = number(a, 2, 'bridge branch merge <n> [--override "reason"] [--dry-run]');
       const reason = flag4(a, "override");
-      const r = await branches.mergeBranch(ctx, { pr: n, ...reason ? { overrideReason: reason } : {}, dryRun: has4(a, "dry-run") });
+      const r = await branches.mergeBranch(ctx, { pr: n, ...reason ? { overrideReason: reason } : {}, dryRun: has5(a, "dry-run") });
       return out(r, () => io.print(r.said));
     }
     case "close": {
@@ -7261,7 +8748,7 @@ async function runBranch(a, root, io = defaultIO()) {
       const n = number(a, 2, "bridge branch update <n> [--choice key=mine|theirs] [--dry-run]");
       const choices = pairs2(a.flags.choice, "choice");
       for (const [k, v] of Object.entries(choices)) if (v !== "mine" && v !== "theirs") throw new RequestUsageError(`--choice ${k}= takes mine or theirs, got "${v}".`);
-      const r = await branches.updateFromMain(ctx, { pr: n, ...Object.keys(choices).length ? { choices } : {}, dryRun: has4(a, "dry-run") });
+      const r = await branches.updateFromMain(ctx, { pr: n, ...Object.keys(choices).length ? { choices } : {}, dryRun: has5(a, "dry-run") });
       return out(r, () => {
         io.print(said(r));
         for (const c of r.conflicts ?? []) io.print(`  ${c.key}  (${c.token}, default ${c.default ?? "none: pick one"})`);
@@ -7294,7 +8781,7 @@ ${BRANCH_HELP}`);
 }
 async function runStudioRead(cmd, a, root, io = defaultIO()) {
   const ctx = await context4(root, io);
-  const json = has4(a, "json");
+  const json = has5(a, "json");
   if (cmd === "products") {
     const r2 = await branches.listProducts(ctx);
     if (json) return io.print(JSON.stringify(r2, null, 2)), 0;
@@ -7345,9 +8832,9 @@ async function runDocsSave(a, root, io = defaultIO()) {
     ...flag4(a, "product") ? { product: flag4(a, "product") } : {},
     ...changes ? { changes } : {},
     source: "cli",
-    dryRun: has4(a, "dry-run")
+    dryRun: has5(a, "dry-run")
   });
-  if (has4(a, "json")) io.print(JSON.stringify(r, null, 2));
+  if (has5(a, "json")) io.print(JSON.stringify(r, null, 2));
   else io.print(r.status === "dry-run" || r.status === "preview" ? `${r.said ?? "Dry run, nothing written."}
 
 ${r.path}:
@@ -7372,7 +8859,7 @@ Usage:
   bridge pieces switch <n>                       once the library shipped: main into the product branch
 
 GitHub token: GITHUB_TOKEN or BRIDGE_GITHUB_TOKEN, else \`gh auth token\`. Exit codes: 0 ok, 2 usage or setup error.`;
-var has5 = (a, k) => Boolean(a.flags[k]);
+var has6 = (a, k) => Boolean(a.flags[k]);
 async function context5(root, io) {
   const token = io.env.BRIDGE_GITHUB_TOKEN || io.env.GITHUB_TOKEN || io.ghToken();
   return BridgeContext6.create({ root, ...token ? { token } : {}, ...io.fetch ? { fetch: io.fetch } : {} });
@@ -7389,11 +8876,11 @@ function piece(a, at, usage) {
 }
 async function runPieces(a, root, io = defaultIO()) {
   const sub = a._[1];
-  if (!sub || sub === "help" || has5(a, "help")) {
+  if (!sub || sub === "help" || has6(a, "help")) {
     io.print(PIECES_HELP);
-    return sub || has5(a, "help") ? 0 : 2;
+    return sub || has6(a, "help") ? 0 : 2;
   }
-  const json = has5(a, "json");
+  const json = has6(a, "json");
   const ctx = await context5(root, io);
   const out = (r, text) => (json ? io.print(JSON.stringify(r, null, 2)) : text(), 0);
   switch (sub) {
@@ -7410,7 +8897,7 @@ async function runPieces(a, root, io = defaultIO()) {
     case "open": {
       const usage = "bridge pieces open <n> <piece>";
       const changes = changesFlag(a);
-      const r = await pieces.openLibraryBranchOp(ctx, { pr: number2(a, 2, usage), piece: piece(a, 3, usage), usePreview: !has5(a, "no-preview"), dryRun: has5(a, "dry-run"), source: "cli", ...changes ? { changes } : {} });
+      const r = await pieces.openLibraryBranchOp(ctx, { pr: number2(a, 2, usage), piece: piece(a, 3, usage), usePreview: !has6(a, "no-preview"), dryRun: has6(a, "dry-run"), source: "cli", ...changes ? { changes } : {} });
       return out(r, () => {
         io.print(`${r.status === "dry-run" ? "Would open" : r.status === "already-linked" ? "Already linked" : r.status === "suggested" ? "Suggested" : "Opened"} a ${r.opens}: ${r.title}, needed by ${r.neededBy}.`);
         if (r.library) io.print(`  #${r.library.number} ${r.library.url}`);
@@ -7429,7 +8916,7 @@ async function runPieces(a, root, io = defaultIO()) {
       return out(r, () => io.print(r.said));
     }
     default: {
-      const r = await pieces.missingPiecesOp(ctx, { pr: number2(a, 1, "bridge pieces <n> [--record]"), record: has5(a, "record") });
+      const r = await pieces.missingPiecesOp(ctx, { pr: number2(a, 1, "bridge pieces <n> [--record]"), record: has6(a, "record") });
       return out(r, () => {
         io.print(`#${r.pr} ${r.branch} (${r.product}): ${r.pieces.length ? `${r.pieces.length} ${r.pieces.length === 1 ? "piece is" : "pieces are"} missing from the library` : "nothing is missing from the library"}, ${r.files} files read.`);
         for (const p of r.pieces) io.print(`  ${p.id}  ${p.title}: ${p.summary} Opens ${p.opens}.${"linked" in p ? ` Linked: #${p.linked}.` : ""}`);
@@ -7459,7 +8946,7 @@ Usage:
                                                  token change, or a branch with the spec for Claude AI
 
 GitHub token: GITHUB_TOKEN or BRIDGE_GITHUB_TOKEN, else \`gh auth token\`. Exit codes: 0 ok, 2 usage or setup error.`;
-var has6 = (a, k) => Boolean(a.flags[k]);
+var has7 = (a, k) => Boolean(a.flags[k]);
 async function context6(root, io) {
   const token = io.env.BRIDGE_GITHUB_TOKEN || io.env.GITHUB_TOKEN || io.ghToken();
   return BridgeContext7.create({ root, ...token ? { token } : {}, ...io.fetch ? { fetch: io.fetch } : {} });
@@ -7471,17 +8958,17 @@ function number3(a, usage) {
 }
 async function runFigma(a, root, io = defaultIO()) {
   const sub = a._[1];
-  if (sub === "help" || has6(a, "help")) {
+  if (sub === "help" || has7(a, "help")) {
     io.print(FIGMA_HELP);
     return 0;
   }
-  const json = has6(a, "json");
+  const json = has7(a, "json");
   const ctx = await context6(root, io);
   const out = (r, text) => (json ? io.print(JSON.stringify(r, null, 2)) : text(), 0);
   switch (sub) {
     case void 0:
     case "list": {
-      const r = await figma.figmaChangesOp(ctx, { state: has6(a, "all") ? "all" : "open" });
+      const r = await figma.figmaChangesOp(ctx, { state: has7(a, "all") ? "all" : "open" });
       return out(r, () => {
         for (const c of r.changes) io.print(`#${c.pr} ${c.title} (${c.route}): ${c.status}. ${c.said}`);
         io.print(`Next: ${r.next}`);
@@ -7489,7 +8976,7 @@ async function runFigma(a, root, io = defaultIO()) {
     }
     case "show": {
       const r = await figma.getFigmaChangeOp(ctx, { pr: number3(a, "bridge figma show <n>") });
-      if (has6(a, "draft")) {
+      if (has7(a, "draft")) {
         if (!r.brief) throw new RequestUsageError(`#${r.pr} is an exact token change: there is no code to draft.`);
         if (!io.hasClaude()) throw new RequestUsageError("`claude` is not on PATH: install Claude Code, or paste the brief from `bridge figma show <n>` into Claude.");
         return io.runClaude(r.brief, root);
@@ -7515,7 +9002,7 @@ ${r.brief}`);
         throw new RequestUsageError(`${file} could not be read as JSON: ${err.message}`);
       }
       const changes = changesFlag(a);
-      const r = await figma.pushFigmaComponentOp(ctx, { diff: diff2, dryRun: has6(a, "dry-run"), source: "cli", ...changes ? { changes } : {} });
+      const r = await figma.pushFigmaComponentOp(ctx, { diff: diff2, dryRun: has7(a, "dry-run"), source: "cli", ...changes ? { changes } : {} });
       return out(r, () => {
         io.print(`${r.component}: ${r.route}. ${r.said}`);
         for (const x of r.reasons ?? []) io.print(`  ${x}`);
@@ -7601,7 +9088,20 @@ async function writeSnapshot(opts) {
 `);
     written.push(summary.path);
   }
-  return { snapshot, written, bytes };
+  let activity;
+  if (opts.activity) {
+    const [owner, name] = (opts.activity.repo ?? `${snapshot.repo.owner}/${snapshot.repo.name}`).split("/");
+    if (!owner || !name) throw new Error('bridge snapshot --activity needs the repository: --repo owner/name, GITHUB_REPOSITORY, or "repo" in bridge.config.json.');
+    const fetchImpl = opts.activity.fetch ?? ((url, init2) => fetch(url, init2));
+    const previous = await new GitHubClient(`${owner}/${name}`, opts.activity.token, fetchImpl, { attempts: 1, baseDelayMs: 0, sleep: async () => {
+    } }, { etags: false }).getRawText(ACTIVITY_FILE, SNAPSHOT_BRANCH).then((t) => t ? parseActivity(t) : null).catch(() => null);
+    const a = await collectActivity({ fetch: fetchImpl, token: opts.activity.token, owner, repo: name, config: model.config, version: opts.version, ...opts.generatedAt ? { generatedAt: opts.generatedAt } : {}, previous });
+    writeFileSync2(join7(opts.out, ACTIVITY_FILE), `${JSON.stringify(a)}
+`);
+    written.push(ACTIVITY_FILE);
+    activity = { activity: a, bytes: activityBytes(a), reused: Boolean(previous && a.history && previous.history === a.history) };
+  }
+  return { snapshot, written, bytes, ...activity ? { activity } : {} };
 }
 function snapshotLines(r, out) {
   const s = r.snapshot;
@@ -7614,7 +9114,24 @@ function snapshotLines(r, out) {
     `  contrast      ${c.checks} checks over ${c.pairs} pairs, ${c.failing} failing`,
     `  figma         ${s.summary.figma ? `${s.summary.figma.inFigma} of ${s.summary.figma.visual} visual components` : "no component-specs.json"}`,
     `  audits        ${s.audits.length ? s.audits.map((a) => a.path).join(", ") : "none (--audit <path> or --audit-report <file|dir>)"}`,
-    ...s.problems.map((p) => `  problem       ${p}`)
+    ...s.problems.map((p) => `  problem       ${p}`),
+    ...activityLines(r, out)
+  ];
+}
+function activityLines(r, out) {
+  if (!r.activity) return [];
+  const a = r.activity.activity;
+  const kb = Math.max(1, Math.round(r.activity.bytes / 1024));
+  const reads = Object.keys(a.responses).length;
+  return [
+    `Wrote ${join7(out, ACTIVITY_FILE)} (${kb} KB): ${reads} GitHub reads recorded for signed-out visitors.`,
+    `  branches      ${a.branches.length} open`,
+    `  suggestions   ${a.suggestions.length} open`,
+    `  requests      ${a.requests.length}`,
+    `  merged        ${a.merged.length} recent`,
+    `  history       ${a.history ? `${a.history.entries.length} token changes${r.activity.reused ? " (kept: the default branch did not move)" : ""}` : "not read"}`,
+    ...a.truncated.map((t) => `  left out      ${t}`),
+    ...a.problems.map((p) => `  problem       ${p}`)
   ];
 }
 
@@ -7651,7 +9168,7 @@ async function rolesReport(opts) {
 
 // src/index.ts
 import { brand, BridgeContext as BridgeContext8, CONFIG_FILE as CONFIG_FILE2, core, detectConfig, GitRefSource, history as hist, LocalSource, ops, optionsFromArgv, serveStdio, toConfigJson } from "@bridge-ds/mcp";
-var VERSION = true ? "0.11.1" : "dev";
+var VERSION = true ? "0.12.0" : "dev";
 var MCP_PACKAGE = "@bridge-ds/mcp";
 var HELP = `bridge ${VERSION}: design system as code, for you and your Claude
 
@@ -7712,11 +9229,14 @@ Usage:
   bridge audit <path> --fix [--write] safe autofix: CSS values equal to a token become var(--token).
                                       Dry run unless --write
   bridge snapshot [--out bridge-data] [--audit <path>[=label] ...] [--audit-report <file|dir> ...]
-                 [--branch main] [--json]
+                 [--branch main] [--activity [--repo owner/name]] [--json]
                                       the repo model of this checkout for hosted Bridge (Studio and Library):
                                       snapshot.json (token, contrast and component files, Figma coverage,
                                       contrast results) plus audits/<id>.json. --audit runs bridge audit on a
                                       product folder; --audit-report carries reports already written.
+                                      --activity also writes activity.json (open branches, suggestions,
+                                      requests, recent merges, token history) read with GITHUB_TOKEN, so
+                                      signed-out visitors of hosted Studio spend no GitHub API request.
                                       The bridge-data workflow publishes the folder to the bridge-data branch
   bridge docs draft <Component> [--json]
                                       docs.json pre-fill from the code (props, tokens, anatomy, contrast,
@@ -7792,7 +9312,7 @@ function parse(argv) {
   return out;
 }
 var flag5 = (a, k) => a.flags[k]?.[a.flags[k].length - 1];
-var has7 = (a, k) => Boolean(a.flags[k]);
+var has8 = (a, k) => Boolean(a.flags[k]);
 var print = (s) => process.stdout.write(`${s}
 `);
 var modeArg = (s) => s ? Object.fromEntries(s.split(",").map((kv) => kv.split("="))) : void 0;
@@ -7808,7 +9328,7 @@ function printSent(r) {
 async function init(a, root) {
   const cfgPath = join8(root, CONFIG_FILE2);
   let config;
-  if (existsSync8(cfgPath) && !has7(a, "force")) {
+  if (existsSync8(cfgPath) && !has8(a, "force")) {
     print(`${CONFIG_FILE2} exists, keeping it (--force to regenerate).`);
     config = (await (await BridgeContext8.create({ root })).config()).config;
   } else {
@@ -7842,10 +9362,10 @@ async function check(a, root) {
   const v = await ops.validateTokens(ctx, { includeWarnings: true });
   const c = await ops.checkContrast(ctx, {});
   const warnings = "warnings" in v ? v.warnings ?? [] : [];
-  const failed = !v.valid || "failing" in c && (c.failing ?? 0) > 0 || has7(a, "strict") && warnings.length > 0;
+  const failed = !v.valid || "failing" in c && (c.failing ?? 0) > 0 || has8(a, "strict") && warnings.length > 0;
   const protection = await protectionOf(a, root, ctx);
   const roles = await rolesOf(a, root, ctx);
-  if (has7(a, "json")) {
+  if (has8(a, "json")) {
     print(JSON.stringify({ ok: !failed, validation: v, contrast: c, ...protection ? { protection: protection.state } : {}, ...roles?.teams.length ? { teams: roles.teams } : {} }, null, 2));
     return failed ? 1 : 0;
   }
@@ -7864,7 +9384,7 @@ async function check(a, root) {
   return failed ? 1 : 0;
 }
 async function protectionOf(a, root, ctx) {
-  if (has7(a, "offline") || process.env.BRIDGE_OFFLINE === "1") return void 0;
+  if (has8(a, "offline") || process.env.BRIDGE_OFFLINE === "1") return void 0;
   const { config } = await ctx.config();
   const repo = config.repo ? `${config.repo.owner}/${config.repo.name}` : await originRepo(root);
   if (!repo) return void 0;
@@ -7872,7 +9392,7 @@ async function protectionOf(a, root, ctx) {
   return protectionReport({ repo, defaultBranch: config.repo?.defaultBranch ?? "main", token });
 }
 async function rolesOf(a, root, ctx) {
-  if (has7(a, "offline") || process.env.BRIDGE_OFFLINE === "1") return void 0;
+  if (has8(a, "offline") || process.env.BRIDGE_OFFLINE === "1") return void 0;
   const { config } = await ctx.config();
   const repo = config.repo ? `${config.repo.owner}/${config.repo.name}` : await originRepo(root);
   if (!repo) return void 0;
@@ -7884,7 +9404,7 @@ async function tokens(a, root) {
   if (!q) throw new UsageError("bridge tokens <query>");
   const ctx = await BridgeContext8.create({ root });
   const r = await ops.searchTokens(ctx, { query: q, limit: Number(flag5(a, "limit") ?? 20) });
-  if (has7(a, "json")) return print(JSON.stringify(r, null, 2));
+  if (has8(a, "json")) return print(JSON.stringify(r, null, 2));
   if (!r.results.length) return print(`No token matches "${q}".`);
   const w = Math.max(...r.results.map((x) => x.path.length));
   for (const t of r.results) print(`${t.path.padEnd(w)}  ${String(t.value).padEnd(10)}  ${(t.tier ?? "").padEnd(9)}  ${t.description ?? ""}`);
@@ -7901,11 +9421,11 @@ async function diff(a, root) {
   const delta2 = pairs3.length ? core.contrastDelta(core.runContrast(before, pairs3, config.contrast?.modes), core.runContrast(after, pairs3, config.contrast?.modes)) : [];
   const tier = core.classify(changes, [], config);
   const imp = core.impact(before, after, changes, 30);
-  if (has7(a, "json")) {
+  if (has8(a, "json")) {
     print(JSON.stringify({ base, changes, contrast: delta2, tier, impact: imp }, null, 2));
     return 0;
   }
-  if (has7(a, "md")) {
+  if (has8(a, "md")) {
     print(`## Token changes since \`${base}\`
 
 ${core.tokenTable(changes)}
@@ -7971,9 +9491,9 @@ async function propose(a, root) {
     ...product ? { product } : {},
     ...changes ? { changes } : {},
     source: "cli",
-    dryRun: has7(a, "dry-run")
+    dryRun: has8(a, "dry-run")
   });
-  if (has7(a, "json")) print(JSON.stringify(r, null, 2));
+  if (has8(a, "json")) print(JSON.stringify(r, null, 2));
   else {
     print(`status: ${r.status}${r.why ? ` (${r.why})` : ""}`);
     if (r.tier) print(`tier ${r.tier}, ${r.bump}`);
@@ -7991,7 +9511,7 @@ async function brandCmd(a, root) {
   const ctx = await BridgeContext8.create({ root, ...token ? { token } : {} });
   if (sub === "list") {
     const r2 = await brand.listBrands(ctx);
-    if (has7(a, "json")) print(JSON.stringify(r2.brands, null, 2));
+    if (has8(a, "json")) print(JSON.stringify(r2.brands, null, 2));
     else for (const b of r2.brands) print(`${b.default ? "*" : " "} ${b.slug.padEnd(14)} ${b.name.padEnd(18)} ${b.primary ?? ""}${b.overrides.length ? `  overrides: ${b.overrides.join(", ")}` : ""}`);
     return 0;
   }
@@ -8013,9 +9533,9 @@ async function brandCmd(a, root) {
     ...opt("notes") ? { notes: opt("notes") } : {},
     ...changes ? { changes } : {},
     source: "cli",
-    dryRun: has7(a, "dry-run")
+    dryRun: has8(a, "dry-run")
   });
-  if (has7(a, "json")) {
+  if (has8(a, "json")) {
     const { fileContents: _f, ...rest } = r;
     print(JSON.stringify(rest, null, 2));
     return r.status === "blocked" ? 1 : 0;
@@ -8049,9 +9569,9 @@ async function figmaReferences(a, root) {
     out: resolve6(root, flag5(a, "out") ?? "figma-references"),
     sha,
     ...only.length ? { only } : {},
-    log: has7(a, "json") ? void 0 : (line2) => print(line2)
+    log: has8(a, "json") ? void 0 : (line2) => print(line2)
   });
-  if (has7(a, "json")) print(JSON.stringify({ manifest: r.manifestPath, captured: r.captured, skipped: r.skipped }, null, 2));
+  if (has8(a, "json")) print(JSON.stringify({ manifest: r.manifestPath, captured: r.captured, skipped: r.skipped }, null, 2));
   return 0;
 }
 async function impact(a, root) {
@@ -8076,15 +9596,15 @@ async function impact(a, root) {
     ...maxStories ? { maxStoriesPerComponent: maxStories } : {},
     ...imageBase !== void 0 ? { imageBase } : {},
     ...artifactUrl ? { artifactUrl } : {},
-    plan: has7(a, "plan"),
-    keepUnchanged: has7(a, "keep-unchanged")
+    plan: has8(a, "plan"),
+    keepUnchanged: has8(a, "keep-unchanged")
   });
-  if (has7(a, "json")) {
+  if (has8(a, "json")) {
     print(JSON.stringify({ summary: r.summary, manifest: r.manifestPath, comment: r.commentPath ?? null, ...r.manifest.summary, selection: r.manifest.selection }, null, 2));
     return 0;
   }
   const sel = r.manifest.selection;
-  if (has7(a, "plan")) {
+  if (has8(a, "plan")) {
     print(`Plan ${r.manifest.base.ref} (${r.manifest.base.sha.slice(0, 7)}) -> ${r.manifest.head.ref} (${r.manifest.head.sha.slice(0, 7)})`);
     print(`  tokens changing value: ${sel.tokens.length}${sel.tokens.length ? ` (${sel.tokens.filter((t) => t.kind === "direct").map((t) => t.path).slice(0, 6).join(", ")})` : ""}`);
     print(`  components: ${sel.components.map((c) => c.id).join(", ") || "none"}`);
@@ -8105,7 +9625,7 @@ async function historyCmd(a, root) {
   const limit = Number(flag5(a, "limit") ?? 20);
   if (token) {
     const r2 = await hist.getTokenHistory(ctx, { path: token, limit });
-    if (has7(a, "json")) return print(JSON.stringify(r2, null, 2)), 0;
+    if (has8(a, "json")) return print(JSON.stringify(r2, null, 2)), 0;
     if (!r2.total) return print(`No recorded change of ${r2.path} in ${r2.source}.`), 0;
     print(`${r2.path}: ${r2.total} change(s)  (${r2.source})
 `);
@@ -8117,8 +9637,8 @@ async function historyCmd(a, root) {
     return 0;
   }
   const tier = flag5(a, "tier");
-  const r = await hist.getHistory(ctx, { limit, ...flag5(a, "author") ? { author: flag5(a, "author") } : {}, ...tier ? { tier: Number(tier) } : {}, ...flag5(a, "version") ? { version: flag5(a, "version") } : {}, ...has7(a, "breaking") ? { breaking: true } : {} });
-  if (has7(a, "json")) return print(JSON.stringify(r, null, 2)), 0;
+  const r = await hist.getHistory(ctx, { limit, ...flag5(a, "author") ? { author: flag5(a, "author") } : {}, ...tier ? { tier: Number(tier) } : {}, ...flag5(a, "version") ? { version: flag5(a, "version") } : {}, ...has8(a, "breaking") ? { breaking: true } : {} });
+  if (has8(a, "json")) return print(JSON.stringify(r, null, 2)), 0;
   print(`${r.source}${r.currentVersion ? `, package version ${r.currentVersion}` : ""}`);
   if (!r.total) return print(r.note ?? "No token change matches."), 0;
   for (const v of r.versions) print(`  ${v.version.padEnd(11)} ${day(v.date)}  ${v.entries} change(s), ${v.tokenChanges} token edit(s)${v.breaking ? ", breaking" : ""}`);
@@ -8140,8 +9660,8 @@ async function revertCmd(a, root) {
   const token = changes !== "direct" ? githubToken() : void 0;
   const ctx = await BridgeContext8.create({ root, ...token ? { token } : {} });
   const resolutions = Object.fromEntries((a.flags["use-before"] ?? []).map((k) => [k, "use-before"]));
-  const r = await hist.proposeRevert(ctx, { target, resolutions, restoreConflicts: has7(a, "restore-conflicts"), dryRun: has7(a, "dry-run"), ...changes ? { changes } : {}, source: "cli" });
-  if (has7(a, "json")) {
+  const r = await hist.proposeRevert(ctx, { target, resolutions, restoreConflicts: has8(a, "restore-conflicts"), dryRun: has8(a, "dry-run"), ...changes ? { changes } : {}, source: "cli" });
+  if (has8(a, "json")) {
     print(JSON.stringify(r, null, 2));
     return r.status === "blocked" ? 1 : 0;
   }
@@ -8168,8 +9688,8 @@ async function audit(a, root) {
   const dsRoot = flag5(a, "ds") ? resolve6(flag5(a, "ds")) : existsSync8(join8(root, CONFIG_FILE2)) ? root : findDesignSystemRoot(root);
   if (!dsRoot) throw new UsageError(`No ${CONFIG_FILE2} found: run bridge audit from the design system repo or pass --ds <dir>.`);
   const ds = loadDesignSystem(dsRoot);
-  if (has7(a, "fix")) {
-    const write = has7(a, "write");
+  if (has8(a, "fix")) {
+    const write = has8(a, "write");
     const changes = fixCss(target, ds.index, write);
     const n = changes.reduce((acc, c) => acc + c.edits.length, 0);
     for (const c of changes) for (const e of c.edits) print(`${c.file}:${e.line}:${e.column}  ${e.from} -> ${e.to}`);
@@ -8245,7 +9765,7 @@ async function audit(a, root) {
       code = 1;
     }
   }
-  if (has7(a, "no-regress") && report.baseline) {
+  if (has8(a, "no-regress") && report.baseline) {
     const b = report.baseline;
     if ((b.tokenAdoption.delta ?? 0) < 0 || (b.componentAdoption.delta ?? 0) < 0 || b.hardcoded.delta > 0) {
       process.stderr.write("bridge audit: adoption regressed since the baseline\n");
@@ -8257,8 +9777,31 @@ async function audit(a, root) {
 async function snapshotCmd(a, root) {
   const out = resolve6(root, flag5(a, "out") ?? "bridge-data");
   const branch = flag5(a, "branch");
-  const r = await writeSnapshot({ root, out, version: VERSION, audit: a.flags.audit ?? [], auditReports: a.flags["audit-report"] ?? [], ...branch ? { branch } : {} });
-  if (has7(a, "json")) print(JSON.stringify({ out, written: r.written, bytes: r.bytes, sourceSha: r.snapshot.sourceSha, summary: r.snapshot.summary, audits: r.snapshot.audits.map((x) => x.path), problems: r.snapshot.problems }, null, 2));
+  let activity;
+  if (has8(a, "activity")) {
+    const token = githubToken();
+    if (!token) throw new UsageError("bridge snapshot --activity reads GitHub: set GITHUB_TOKEN (in a workflow, the run token is enough).");
+    const repo = flag5(a, "repo") || process.env.GITHUB_REPOSITORY || void 0;
+    activity = { token, ...repo ? { repo } : {} };
+  }
+  const r = await writeSnapshot({ root, out, version: VERSION, audit: a.flags.audit ?? [], auditReports: a.flags["audit-report"] ?? [], ...branch ? { branch } : {}, ...activity ? { activity } : {} });
+  if (has8(a, "json"))
+    print(
+      JSON.stringify(
+        {
+          out,
+          written: r.written,
+          bytes: r.bytes,
+          sourceSha: r.snapshot.sourceSha,
+          summary: r.snapshot.summary,
+          audits: r.snapshot.audits.map((x) => x.path),
+          problems: r.snapshot.problems,
+          ...r.activity ? { activity: { bytes: r.activity.bytes, reads: Object.keys(r.activity.activity.responses).length, branches: r.activity.activity.branches.length, suggestions: r.activity.activity.suggestions.length, requests: r.activity.activity.requests.length, merged: r.activity.activity.merged.length, history: r.activity.activity.history?.entries.length ?? null, truncated: r.activity.activity.truncated, problems: r.activity.activity.problems } } : {}
+        },
+        null,
+        2
+      )
+    );
   else {
     const shown = relative5(process.cwd(), out);
     for (const line2 of snapshotLines(r, shown.startsWith("..") || isAbsolute(shown) ? out : shown || ".")) print(line2);
@@ -8270,7 +9813,7 @@ async function docsCmd(a, root) {
   if (sub !== "draft" || !name) throw new UsageError("Usage: bridge docs draft <Component> [--json]");
   const ctx = await BridgeContext8.create({ root });
   const d = await ops.draftDocsOp(ctx, { name });
-  if (has7(a, "json")) {
+  if (has8(a, "json")) {
     print(JSON.stringify({ component: d.component, path: d.path, exists: d.exists, prefill: d.prefill, prompt: d.prompt }, null, 2));
     return 0;
   }
@@ -8312,10 +9855,10 @@ async function main() {
   if (cmd === "review") return runReview(a, root);
   if (cmd === "products" || cmd === "settings" || cmd === "coverage") return runStudioRead(cmd, a, root);
   if (cmd === "docs" && a._[1] === "save") return runDocsSave(a, root);
-  if (cmd === "version" || !cmd && has7(a, "version")) return print(VERSION), 0;
-  if (!cmd || has7(a, "help") || cmd === "help") {
+  if (cmd === "version" || !cmd && has8(a, "version")) return print(VERSION), 0;
+  if (!cmd || has8(a, "help") || cmd === "help") {
     print(HELP);
-    return cmd || has7(a, "help") ? 0 : 2;
+    return cmd || has8(a, "help") ? 0 : 2;
   }
   switch (cmd) {
     case "init":