@bridge-ds/mcp 0.8.2 → 0.8.4

package/dist/{chunk-QCPYJXK4.js → chunk-HZWFI7A2.js}

@@ -79,7 +79,7 @@ import {
   validateLayered,
   variantKeyOf,
   whoCanShipSentence
-} from "./chunk-DPK46GA2.js";
+} from "./chunk-PMZGEZGX.js";
 
 // src/lib.ts
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -3923,6 +3923,33 @@ function explorationRules(branch) {
   ];
 }
 
+// ../core/src/titles.ts
+var escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function properWord(word, names3) {
+  const bare = word.replace(/[^\p{L}\p{N}]+$/u, "");
+  if (!bare) return false;
+  if (names3.some((n) => n === bare)) return true;
+  return new RegExp("\\p{Lu}", "u").test(bare.slice(1));
+}
+function lowerFirstWord(text, names3 = []) {
+  const first = text.split(/\s+/)[0] ?? "";
+  if (!first || properWord(first, names3)) return text;
+  return `${text.charAt(0).toLowerCase()}${text.slice(1)}`;
+}
+function subjectTitle(subject, title, names3 = []) {
+  const t = title.trim().replace(/\.$/, "");
+  const keep = [subject, ...names3];
+  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." },
@@ -3939,8 +3966,7 @@ var MARK2 = "bridge-request";
 var kindLabel = (k) => REQUEST_KINDS.find((x) => x.value === k)?.label ?? "Other";
 var kindSlug = (k) => `request: ${k}`;
 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 composeRequestIssue(r, opts = {}) {
   const rows = r.changes.length ? ["| What | Now | Requested |", "| --- | --- | --- |", ...r.changes.map((c) => `| ${cell2(c.field)} | ${cell2(c.before ?? "")} | ${cell2(c.after ?? "")} |`)] : [];
@@ -4549,15 +4575,36 @@ function reviewStatusKind(input) {
   if (input.mergeable === false) return out("conflict");
   if (input.ci?.state === "pending") return out("ci-running");
   if (!input.ci || !input.approvals) return out("unknown");
-  if (input.mergeable === null) return out("checking");
   const tier = input.tier ?? 3;
   if (tier >= 2) {
     if (!input.approvals.design) return out("needs-design");
     if (!input.approvals.tech) return out("needs-tech");
   } else if (!input.approvals.approvers.length) return out("needs-approval");
+  if (input.mergeable === null) return out("checking");
   const gate = mergeGate({ tier: input.tier, ci: input.ci, approvals: input.approvals, draft: Boolean(input.draft), mergeable: input.mergeable, state: input.state ?? "open", merged_at: input.merged_at });
   return gate.allowed ? out("ready") : out("unknown");
 }
+var REVIEW_STATUS_LABEL = {
+  merged: "Merged",
+  closed: "Closed",
+  draft: "Draft",
+  "ci-failing": "Blocked by tests",
+  "changes-requested": "Changes requested",
+  "ci-running": "Tests running",
+  "needs-design": "Needs design approval",
+  "needs-tech": "Needs tech approval",
+  "needs-approval": "Needs approval",
+  conflict: "Conflict with main",
+  checking: "Checking for conflicts",
+  ready: "Ready to merge",
+  unknown: "Status unknown"
+};
+var CI_STATE_LABEL = {
+  pass: "Tests pass",
+  fail: "Tests fail",
+  pending: "Tests running",
+  none: "No automated checks"
+};
 var BOTS = /* @__PURE__ */ new Set(["github-actions[bot]", "app/github-actions", "changeset-bot[bot]"]);
 var isReleasePull = (p) => p.head.ref.startsWith("changeset-release/");
 function isAutomationPull(p) {
@@ -5400,6 +5447,10 @@ var SUGGESTION_STATE_LABELS = {
   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",
@@ -5620,8 +5671,8 @@ function suggestionSubject(p) {
   return KIND_SUBJECT[p.kind];
 }
 function suggestionIssueTitle(p) {
-  const t = p.title.trim().replace(/\.$/, "");
-  return `${suggestionSubject(p)}: ${t.charAt(0).toLowerCase()}${t.slice(1)}`;
+  const names3 = [...(p.docs ?? []).map((d) => d.component), ...p.componentSpec?.component ? [p.componentSpec.component] : []];
+  return subjectTitle(suggestionSubject(p), p.title, names3);
 }
 function suggestionLabels(p, opts = {}) {
   return [
@@ -5655,9 +5706,22 @@ function suggestionStatus(i) {
   if (i.outdated) return "outdated";
   return i.review ?? "needs-review";
 }
+function withOutdated(status, outdated) {
+  return outdated && (status === "needs-review" || status === "changes-requested" || status === "approved") ? "outdated" : status;
+}
 function suggestionStateLabel(status) {
+  if (status === "applied" || status === "declined") return SUGGESTION_FINAL_LABELS[status];
   return status in SUGGESTION_STATE_LABELS ? SUGGESTION_STATE_LABELS[status] : null;
 }
+var SUGGESTION_STATUS_LABELS = [...Object.values(SUGGESTION_STATE_LABELS), ...Object.values(SUGGESTION_FINAL_LABELS)];
+function suggestionLabelChanges(labels, status) {
+  if (status === "outdated") return { add: [], remove: [] };
+  const want = suggestionStateLabel(status);
+  return {
+    add: want && !labels.includes(want) ? [want] : [],
+    remove: SUGGESTION_STATUS_LABELS.filter((l) => l !== want && labels.includes(l))
+  };
+}
 var bridgeMcpInstallCommand = (repo) => `claude mcp add bridge -s user -- npx -y @bridge-ds/mcp --repo ${repo?.trim() || "<owner/name>"}`;
 var MARK3 = "bridge-suggestion";
 var PART_SCHEMA = "bridge.suggestion-part/1";
@@ -6044,97 +6108,422 @@ function suggestionPathProblems(p, config) {
   return [...new Set(out)];
 }
 
-// ../core/src/suggestions-github.ts
-async function createSuggestionOnGitHub(gh, payload, opts = {}) {
-  const issue = composeSuggestionIssue(payload, { repo: gh.fullName, ...opts });
-  const created = await gh.createIssue({ title: issue.title, body: issue.body, labels: issue.labels, assignees: issue.assignees });
-  for (const [i, part] of issue.parts.entries()) {
-    try {
-      await gh.createIssueComment(created.number, part);
-    } catch (err) {
-      const why = err instanceof Error ? err.message : String(err);
-      throw new GitHubError(err instanceof GitHubError ? err.status : 500, `Suggestion #${created.number} is incomplete: part ${i + 1} of ${issue.parts.length} could not be posted (${why}). Send it again, then close #${created.number}.`);
-    }
-  }
-  const warnings = [];
-  const missing = issue.labels.filter((l) => !created.labels.includes(l));
-  if (created.labels.length && missing.length) warnings.push(`GitHub did not keep these labels on #${created.number}: ${missing.join(", ")}.`);
-  return { number: created.number, url: created.url, sha: issue.sha, parts: issue.parts.length, warnings };
+// ../core/src/suggestion-apply.ts
+var SUGGESTION_APPLY_EXIT = {
+  ready: 0,
+  "already-applied": 0,
+  conflict: 3,
+  "not-approved": 1,
+  blocked: 1,
+  refused: 1
+};
+var same2 = (a, b) => canonicalJson(a) === canonicalJson(b);
+var show3 = (v) => v === void 0 ? "nothing" : typeof v === "string" ? v : JSON.stringify(v);
+function tokenRoot(config) {
+  const r = config.tokens.root.replace(/\/+$/, "");
+  return r === "." ? "" : r;
 }
-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" }));
+function tokenFileOf(config, path) {
+  const root = tokenRoot(config);
+  if (root && !path.startsWith(`${root}/`)) return null;
+  if (!selectTokenFiles(config, [path]).length) return null;
+  return root ? path.slice(root.length + 1) : path;
 }
-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 planTokenEdit(set, e, changes) {
+  const base = { type: "token", path: e.path, edit: e, ...e.file ? { file: e.file } : {} };
+  const defsAt = (path) => set.defs.filter((d) => d.path === path && (!e.file || d.file === e.file));
+  const recorded = (file, path = e.path) => changes.find((c) => c.path === path && c.file === file && (e.op === "rename" ? c.kind === "renamed" : true));
+  const conflict = (detail, extra = {}) => ({ op: { ...base, state: "conflict", detail, ...extra }, notes: [] });
+  const done = (detail) => ({ op: { ...base, state: "already-applied", detail }, notes: [] });
+  let result;
+  try {
+    result = applyTokenEdits(set, [e]);
+  } catch (err) {
+    const why = err instanceof Error ? err.message : String(err);
+    switch (e.op) {
+      case "rename": {
+        const hasOld = defsAt(e.path).length > 0;
+        const hasNew = set.defs.some((d) => d.path === e.newPath);
+        if (!hasOld && hasNew) return done(`Already renamed to ${e.newPath}.`);
+        return conflict(hasOld && hasNew ? `Both ${e.path} and ${e.newPath} exist now: rename it by hand.` : `${e.path} no longer exists: ${why}`);
+      }
+      case "remove":
+        if (!defsAt(e.path).length) return done("Already removed.");
+        return conflict(why);
+      case "add": {
+        const existing = defsAt(e.path);
+        if (!existing.length) return conflict(why);
+        const want = (file) => {
+          const c = recorded(file);
+          if (c && c.after !== void 0) return c.after;
+          return coerceValue(e.value, e.type ?? existing.find((d2) => d2.file === file)?.type);
+        };
+        const all = existing.every((d2) => same2(d2.value, want(d2.file)));
+        if (all) return done("Already added with the suggested value.");
+        const d = existing.find((x) => !same2(x.value, want(x.file)));
+        return conflict(`Someone added ${e.path} with another value since.`, { file: d.file, after: want(d.file), now: d.value });
+      }
+      default:
+        return conflict(defsAt(e.path).length ? why : `${e.path} no longer exists, so its value cannot be set.`);
+    }
+  }
+  if (!result.touched.length) return done("Already has the suggested value.");
+  if (e.op === "set" || e.op === "remove" || e.op === "rename") {
+    for (const d of defsAt(e.path)) {
+      const c = recorded(d.file, e.op === "rename" ? e.newPath ?? e.path : e.path);
+      if (!c) continue;
+      const okNow = same2(d.value, c.before) || e.op === "set" && same2(d.value, c.after);
+      if (!okNow) return conflict(`${e.path} changed since it was suggested (now ${show3(d.value)}, suggested from ${show3(c.before)}).`, { file: d.file, before: c.before, after: c.after, now: d.value });
+    }
+  }
+  const verb = e.op === "set" ? "Set" : e.op === "add" ? "Add" : e.op === "remove" ? "Remove" : `Rename to ${e.newPath ?? ""}`;
+  return { op: { ...base, state: "apply", detail: `${verb} in ${result.touched.join(", ")}.` }, files: result.files, notes: result.notes };
 }
-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 planFile(ws, baseSha, f) {
+  const base = { type: "file", path: f.path };
+  const cur = await ws.read(f.path);
+  const curSha = cur?.sha ?? null;
+  const theirs = f.afterSha === null ? null : f.content ?? null;
+  if (curSha === f.afterSha) return { op: { ...base, state: "already-applied", detail: f.afterSha === null ? "Already deleted." : "Already has the suggested content." } };
+  if (curSha === f.beforeSha) return { op: { ...base, state: "apply", detail: f.afterSha === null ? "Delete it." : f.beforeSha === null ? "Create it." : "Replace it with the suggested content." }, content: theirs };
+  if (f.beforeSha === null) return { op: { ...base, state: "conflict", detail: "The suggestion creates this file, but a different one exists now." } };
+  if (!cur) return { op: { ...base, state: "conflict", detail: "The suggestion changes this file, but it was deleted since." } };
+  if (theirs === null) return { op: { ...base, state: "conflict", detail: "The suggestion deletes this file, but it changed since." } };
+  const original = await ws.readAt(baseSha, f.path);
+  if (original === null || gitBlobSha(original) !== f.beforeSha || !ws.merge) {
+    return { op: { ...base, state: "conflict", detail: original === null ? "The file changed since and its version at the suggestion base cannot be read, so it cannot be merged." : "The file changed since and cannot be merged here." } };
+  }
+  const merged = await ws.merge({ path: f.path, ours: cur.text, base: original, theirs });
+  if (!merged.clean) return { op: { ...base, state: "conflict", detail: `The file changed since and the merge has ${merged.conflicts} conflict(s).`, hunks: merged.conflicts } };
+  if (merged.text === cur.text) return { op: { ...base, state: "already-applied", detail: "Already has the suggested lines." } };
+  return { op: { ...base, state: "apply-merged", detail: "The file changed since: merged with the suggested lines, no conflict." }, content: merged.text };
 }
-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
+async function planSuggestionApply(input) {
+  const { parsed, config, workspace: ws } = input;
+  const payload = parsed.payload;
+  const notes = [];
+  const out = (outcome, message, rest2 = {}) => ({
+    outcome,
+    exitCode: SUGGESTION_APPLY_EXIT[outcome],
+    message,
+    payloadSha: parsed.sha,
+    payload,
+    gate: null,
+    ops: [],
+    writes: [],
+    checks: null,
+    problems: [],
+    notes,
+    ...payload.componentSpec ? { brief: payload.componentSpec.brief } : {},
+    ...rest2
   });
-  return { issue, parsed, comments, approvals, linkedPrs, applied, status };
-}
-async function syncSuggestionStateLabel(gh, n, labels, status) {
-  const want = suggestionStateLabel(status);
-  let ok2 = true;
-  for (const l of Object.values(SUGGESTION_STATE_LABELS)) {
-    if (l === want || !labels.includes(l)) continue;
-    try {
-      await gh.removeLabel(n, l);
-    } catch {
-      ok2 = false;
+  const problems = suggestionPathProblems(payload, config);
+  if (payload.checks.blocked) problems.push(`It was suggested with a failing check (${payload.checks.blocked}): ask the author to fix it and send it again.`);
+  for (const f of payload.files ?? []) {
+    if (f.afterSha !== null && typeof f.content !== "string") problems.push(`"${f.path}" has no content in the suggestion: it is incomplete, ask the author to send it again.`);
+    else if (f.afterSha !== null && gitBlobSha(f.content) !== f.afterSha) problems.push(`"${f.path}" does not match the content it was suggested with: someone edited it by hand.`);
+  }
+  if (problems.length) return out("refused", "Not applied: the suggestion asks for something Bridge never writes.", { problems: [...new Set(problems)] });
+  if (parsed.edited && !input.acceptEdited) {
+    return out("refused", 'Not applied: the suggestion was edited by hand since Bridge wrote it. Read the change, then apply it with "accept edited" if it is right.', {
+      problems: ["The payload no longer matches the sha Bridge recorded."]
+    });
+  }
+  const root = tokenRoot(config);
+  const tokenFiles = selectTokenFiles(config, await ws.list());
+  const targets = [
+    ...(payload.files ?? []).map((f) => f.path),
+    ...(payload.docs ?? []).map((d) => d.path),
+    ...payload.componentSpec ? [payload.componentSpec.specPath] : [],
+    ...payload.tokens?.edits.length ? tokenFiles.map((f) => root ? `${root}/${f}` : f) : []
+  ];
+  if (ws.isSymlink) {
+    const links = [];
+    for (const p of new Set(targets)) if (await ws.isSymlink(p)) links.push(`"${p}" is a symbolic link (or inside one): Bridge never writes through links.`);
+    if (links.length) return out("refused", "Not applied: the suggestion writes through a symbolic link.", { problems: links });
+  }
+  const governance = input.governance ?? { owners: config.governance.owners, rights: config.governance.rights ?? null, soloOwnerCanApproveBoth: config.governance.soloOwnerCanApproveBoth };
+  const approvals = summarizeSuggestionApprovals(input.comments, governance, { payloadSha: parsed.sha, author: input.author });
+  const review = suggestionReviewState(payload.tier.tier, approvals);
+  const missing = pendingApprovals(payload.tier.tier, approvals);
+  const approved = review === "approved";
+  const gate = { review, missing, approvals, forced: !approved && Boolean(input.forceUnapproved), edited: parsed.edited };
+  const ops = [];
+  const writes = /* @__PURE__ */ new Map();
+  const current = /* @__PURE__ */ new Map();
+  for (const f of tokenFiles) {
+    const r = await ws.read(root ? `${root}/${f}` : f);
+    if (r) current.set(f, r.text);
+  }
+  const before = new LayeredTokenSet(config, current);
+  let set = before;
+  const appliedEdits = [];
+  for (const e of payload.tokens?.edits ?? []) {
+    const r = planTokenEdit(set, e, payload.tokens.changes);
+    ops.push(r.op);
+    notes.push(...r.notes);
+    if (r.op.state === "apply" && r.files) {
+      set = new LayeredTokenSet(config, r.files);
+      appliedEdits.push(e);
     }
   }
-  if (want && !labels.includes(want)) ok2 = await gh.addLabels(n, [want]) && ok2;
-  return ok2 ? null : `The state label on #${n} could not be updated; the status shown in Bridge is still right.`;
-}
-async function reviewSuggestionOnGitHub(gh, n, input, gov) {
-  if (input.event === "request-changes" && !input.message?.trim()) throw new GitHubError(422, "Say what should change, in a sentence or two: the author reads it.");
-  const before = await getSuggestionOnGitHub(gh, n, gov);
-  if (!before.parsed.ok) throw new GitHubError(422, `#${n} cannot be reviewed: ${before.parsed.message}`);
-  if (before.issue.state === "closed") throw new GitHubError(422, `#${n} is closed. Reopen it on GitHub to review it again.`);
-  const sha = before.parsed.sha;
-  if (input.payloadSha && input.payloadSha !== sha) throw new GitHubError(409, `#${n} changed since you opened it. Reload it and review the new version.`);
-  const by = input.by ?? (await gh.getViewer().catch(() => ({ login: "" }))).login;
-  const body = composeSuggestionReviewComment({ event: input.event, role: input.role, payloadSha: sha, at: (input.at ?? /* @__PURE__ */ new Date()).toISOString(), by: by || void 0, message: input.message });
-  const posted = await gh.createIssueComment(n, body);
-  const after = await getSuggestionOnGitHub(gh, n, gov);
-  const status = after.status;
-  const who = (after.comments.find((c) => c.id === posted.id)?.author ?? by).toLowerCase();
-  const counts = input.event === "comment" || [...after.approvals?.approvers ?? [], ...after.approvals?.changesRequested ?? []].some((l) => l.toLowerCase() === who);
-  const warnings = [];
-  if (!counts) warnings.push("Your review is posted but does not count: only the owners listed in bridge.config.json approve suggestions.");
-  if (before.parsed.edited) warnings.push(`#${n} was edited by hand after Bridge wrote it: check the machine-readable block before applying it.`);
+  for (const [f, text] of set.files) if (text !== before.files.get(f)) writes.set(set.repoPath(f), text);
+  for (const f of payload.files ?? []) {
+    if (writes.has(f.path)) {
+      notes.push(`${f.path}: the token edits write this file, its copy in the suggestion is not used.`);
+      continue;
+    }
+    const r = await planFile(ws, payload.base.sha, f);
+    ops.push(r.op);
+    if (r.op.state === "apply" || r.op.state === "apply-merged") writes.set(f.path, r.content ?? null);
+  }
+  for (const d of payload.docs ?? []) {
+    const base = { type: "docs", path: d.path };
+    const docs = d.after;
+    let text;
+    try {
+      const issues = validateDocs(docs);
+      if (issues.length) {
+        problems.push(`${d.path}: ${issues.map((i) => i.message).join(" ")}`);
+        continue;
+      }
+      const cur = await ws.read(d.path);
+      text = docsFileText(docs, cur?.text ?? null);
+      if (cur && text === cur.text) {
+        ops.push({ ...base, state: "already-applied", detail: "The docs already say this." });
+        continue;
+      }
+      ops.push({ ...base, state: "apply", detail: cur ? "Update the changed fields; other fields stay as they are now." : "Create the docs file." });
+      writes.set(d.path, text);
+    } catch (err) {
+      problems.push(`${d.path}: the suggested docs are not a docs.json Bridge can read (${err instanceof Error ? err.message : String(err)}).`);
+    }
+  }
+  if (payload.componentSpec) {
+    const s = payload.componentSpec;
+    const text = `${JSON.stringify(s.spec, null, 2)}
+`;
+    const cur = await ws.read(s.specPath);
+    if (cur && cur.text === text) ops.push({ type: "component-spec", path: s.specPath, state: "already-applied", detail: "The spec file is already there." });
+    else {
+      ops.push({ type: "component-spec", path: s.specPath, state: "apply", detail: `Write the spec; the ${s.component} code itself is written from the brief.` });
+      writes.set(s.specPath, text);
+    }
+  }
+  const afterFiles = new Map(set.files);
+  for (const [p, content] of writes) {
+    const tf = tokenFileOf(config, p);
+    if (!tf) continue;
+    if (content === null) afterFiles.delete(tf);
+    else afterFiles.set(tf, content);
+  }
+  const after = new LayeredTokenSet(config, afterFiles);
+  const tokenChanges = diffLayered(before, after);
+  const issueKey4 = (i) => `${i.code}|${i.path ?? ""}|${i.file ?? ""}|${i.message}`;
+  const prevErrors = new Set(validateLayered(before).map(issueKey4));
+  const newErrors = tokenChanges.length ? validateLayered(after).filter((i) => i.level === "error" && !prevErrors.has(issueKey4(i))) : [];
+  let pairs = [];
+  if (config.contrast && tokenChanges.length) {
+    try {
+      pairs = parseContrastChecks((await ws.read(config.contrast.path))?.text);
+    } catch {
+      notes.push(`${config.contrast.path} does not parse: contrast was not checked.`);
+    }
+  }
+  const modes = config.contrast?.modes;
+  const contrast = pairs.length ? contrastDelta(runLayeredContrast(before, pairs, modes), runLayeredContrast(after, pairs, modes)) : [];
+  const newFailures = contrast.filter((d) => d.passBefore && !d.passAfter);
+  const otherFiles = [...writes.keys()].filter((p) => !tokenFileOf(config, p));
+  const tier = classifyRisk({ tokenChanges: tokenChanges.map((c) => ({ kind: c.kind, path: c.path, ...c.kind === "changed" ? { descriptionOnly: c.fields.length > 0 && c.fields.every((x) => x === "description") } : {} })), files: otherFiles.map((path) => ({ path })), config });
+  const tierIncreased = writes.size > 0 && tier.tier > payload.tier.tier;
+  const checks = { tierWhenSuggested: payload.tier.tier, tier, tierIncreased, newErrors, newFailures, contrast, tokenChanges };
+  const rest = { gate, ops, checks, problems };
+  if (problems.length) return out("refused", "Not applied: part of the suggestion is not valid.", rest);
+  const conflicts = ops.filter((o) => o.state === "conflict");
+  if (conflicts.length) {
+    return out("conflict", `Not applied: ${conflicts.length} change(s) conflict with the code now. Ask the author to refresh the suggestion on today's code, or apply those parts by hand.`, rest);
+  }
+  if (!writes.size) return out("already-applied", "Already applied: the code has every change of this suggestion.", rest);
+  if (newErrors.length || newFailures.length) {
+    const why = [newErrors.length ? `${newErrors.length} new validation error(s)` : "", newFailures.length ? `${newFailures.length} contrast pair(s) would fail` : ""].filter(Boolean).join(" and ");
+    return out("blocked", `Not applied: on today's code it would add ${why}. Ask the author to refresh the suggestion.`, rest);
+  }
+  if (tierIncreased && !input.forceUnapproved) {
+    return out("blocked", `Not applied: on today's code it is a tier ${tier.tier} change, it was approved as tier ${payload.tier.tier}. It needs a new approval.`, rest);
+  }
+  if (!approved && !input.forceUnapproved) {
+    const who = review === "changes-requested" ? `changes requested by ${approvals.changesRequested.map((l) => `@${l}`).join(", ")}` : `missing ${missing.map((m) => m === "approval" ? "an approval" : `${m} approval`).join(" and ")}`;
+    return out("not-approved", `Not applied: it is not approved yet (${who}). Ask the owners to review it on the issue.`, rest);
+  }
+  const forced = gate.forced || tierIncreased && Boolean(input.forceUnapproved);
+  return out("ready", `Ready: ${writes.size} file(s) to write${forced ? ", without every approval" : ""}.`, {
+    ...rest,
+    gate: { ...gate, forced },
+    writes: [...writes].map(([path, content]) => ({ path, content })).sort((a, b) => a.path.localeCompare(b.path))
+  });
+}
+function suggestionAppliedComment(plan, where2) {
+  return composeSuggestionAppliedComment({ ...where2, payloadSha: plan.payloadSha, ...plan.gate?.forced ? { forced: true } : {} });
+}
+function suggestionApplyTable(plan) {
+  const label = { "already-applied": "already applied", apply: "apply", "apply-merged": "apply (merged)", conflict: "**conflict**" };
+  const cell4 = (s) => s.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
+  return ["| Change | Result | Detail |", "| --- | --- | --- |", ...plan.ops.map((o) => `| \`${cell4(o.path)}\` | ${label[o.state]} | ${cell4(o.detail)} |`)].join("\n");
+}
+
+// ../core/src/suggestions-github.ts
+async function createSuggestionOnGitHub(gh, payload, opts = {}) {
+  const issue = composeSuggestionIssue(payload, { repo: gh.fullName, ...opts });
+  const created = await gh.createIssue({ title: issue.title, body: issue.body, labels: issue.labels, assignees: issue.assignees });
+  for (const [i, part] of issue.parts.entries()) {
+    try {
+      await gh.createIssueComment(created.number, part);
+    } catch (err) {
+      const why = err instanceof Error ? err.message : String(err);
+      throw new GitHubError(err instanceof GitHubError ? err.status : 500, `Suggestion #${created.number} is incomplete: part ${i + 1} of ${issue.parts.length} could not be posted (${why}). Send it again, then close #${created.number}.`);
+    }
+  }
+  const warnings = [];
+  const missing = issue.labels.filter((l) => !created.labels.includes(l));
+  if (created.labels.length && missing.length) warnings.push(`GitHub did not keep these labels on #${created.number}: ${missing.join(", ")}.`);
+  return { number: created.number, url: created.url, sha: issue.sha, parts: issue.parts.length, warnings };
+}
+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 };
+}
+async function syncSuggestionStateLabel(gh, n, labels, status) {
+  const { add, remove } = suggestionLabelChanges(labels, status);
+  let ok2 = true;
+  for (const l of remove) {
+    try {
+      await gh.removeLabel(n, l);
+    } catch {
+      ok2 = false;
+    }
+  }
+  if (add.length) ok2 = await gh.addLabels(n, add) && ok2;
+  return ok2 ? null : `The status label on #${n} could not be updated; the status shown in Bridge is still right.`;
+}
+async function markSuggestionsAppliedOnGitHub(gh, pr) {
+  const applied = [];
+  const warnings = [];
+  for (const n of closingIssueNumbers(pr.body)) {
+    try {
+      const issue = await gh.getIssue(n);
+      if (!issue.labels.includes(SUGGESTION_LABEL)) continue;
+      const w = await syncSuggestionStateLabel(gh, n, issue.labels, "applied");
+      if (w) warnings.push(w);
+      else applied.push(n);
+    } catch (err) {
+      warnings.push(`Suggestion #${n} could not be marked applied (${err instanceof Error ? err.message : String(err)}).`);
+    }
+  }
+  return { applied, warnings };
+}
+function githubSuggestionWorkspace(gh, ref) {
+  let files;
+  return {
+    read: async (path) => await gh.getFile(path, ref) ?? null,
+    readAt: async (sha, path) => await gh.readFile(path, sha).catch(() => void 0) ?? null,
+    list: () => files ??= gh.listFiles(ref)
+  };
+}
+function suggestionTouches(payload, config, path) {
+  if (path === CONFIG_FILE) return true;
+  if ((payload.files ?? []).some((f) => f.path === path)) return true;
+  if ((payload.docs ?? []).some((d) => d.path === path)) return true;
+  if (payload.componentSpec?.specPath === path) return true;
+  return Boolean(payload.tokens?.edits.length) && selectTokenFiles(config, [path]).length > 0;
+}
+var MAX_COMPARE_FILES = 300;
+async function suggestionStalenessOnGitHub(gh, d, input) {
+  const none = (mainSha2, mainMoved) => ({ mainSha: mainSha2, mainMoved, outdated: false, conflicts: [], plan: null });
+  if (!d.parsed.ok || d.issue.state !== "open") return none(null, false);
+  const payload = d.parsed.payload;
+  const ref = input.ref ?? (payload.base.ref || input.config.repo?.defaultBranch || "main");
+  const mainSha = await gh.getBranchSha(ref).catch(() => void 0) ?? null;
+  if (!mainSha) return none(null, false);
+  if (mainSha === payload.base.sha) return none(mainSha, false);
+  const changed = await gh.compare(payload.base.sha, mainSha).catch(() => null);
+  if (changed && changed.files.length < MAX_COMPARE_FILES && !changed.files.some((f) => suggestionTouches(payload, input.config, f.filename))) return none(mainSha, true);
+  try {
+    const plan = await planSuggestionApply({
+      parsed: d.parsed,
+      config: input.config,
+      comments: d.comments,
+      governance: input.governance,
+      author: d.issue.author || null,
+      // Only whether it still applies: approvals and a hand edit are reported apart.
+      forceUnapproved: true,
+      acceptEdited: true,
+      workspace: githubSuggestionWorkspace(gh, mainSha)
+    });
+    const conflicts = plan.ops.filter((o) => o.state === "conflict");
+    return { mainSha, mainMoved: true, outdated: conflicts.length > 0, conflicts, plan };
+  } catch {
+    return none(mainSha, true);
+  }
+}
+function stalenessStatus(status, staleness) {
+  return withOutdated(status, staleness?.outdated);
+}
+async function reviewSuggestionOnGitHub(gh, n, input, gov) {
+  if (input.event === "request-changes" && !input.message?.trim()) throw new GitHubError(422, "Say what should change, in a sentence or two: the author reads it.");
+  const before = await getSuggestionOnGitHub(gh, n, gov);
+  if (!before.parsed.ok) throw new GitHubError(422, `#${n} cannot be reviewed: ${before.parsed.message}`);
+  if (before.issue.state === "closed") throw new GitHubError(422, `#${n} is closed. Reopen it on GitHub to review it again.`);
+  const sha = before.parsed.sha;
+  if (input.payloadSha && input.payloadSha !== sha) throw new GitHubError(409, `#${n} changed since you opened it. Reload it and review the new version.`);
+  const by = input.by ?? (await gh.getViewer().catch(() => ({ login: "" }))).login;
+  const body = composeSuggestionReviewComment({ event: input.event, role: input.role, payloadSha: sha, at: (input.at ?? /* @__PURE__ */ new Date()).toISOString(), by: by || void 0, message: input.message });
+  const posted = await gh.createIssueComment(n, body);
+  const after = await getSuggestionOnGitHub(gh, n, gov);
+  const status = after.status;
+  const who = (after.comments.find((c) => c.id === posted.id)?.author ?? by).toLowerCase();
+  const counts = input.event === "comment" || [...after.approvals?.approvers ?? [], ...after.approvals?.changesRequested ?? []].some((l) => l.toLowerCase() === who);
+  const warnings = [];
+  if (!counts) warnings.push("Your review is posted but does not count: only the owners listed in bridge.config.json approve suggestions.");
+  if (before.parsed.edited) warnings.push(`#${n} was edited by hand after Bridge wrote it: check the machine-readable block before applying it.`);
   const labelWarning = await syncSuggestionStateLabel(gh, n, before.issue.labels, status);
   if (labelWarning) warnings.push(labelWarning);
   return { commentUrl: posted.url, payloadSha: sha, status, counts, warnings };
@@ -6143,8 +6532,12 @@ async function linkSuggestionPrOnGitHub(gh, n, link) {
   if (!link.pr && !link.branch && !link.commit) throw new GitHubError(422, "Say where it is applied: a pull request number, a branch or a commit.");
   const issue = await gh.getIssue(n);
   await gh.addComment(n, composeSuggestionAppliedComment({ by: link.by, branch: link.branch, commit: link.commit, pr: link.pr, payloadSha: link.payloadSha, forced: link.forced, at: (link.at ?? /* @__PURE__ */ new Date()).toISOString() }));
-  const warning = await syncSuggestionStateLabel(gh, n, issue.labels, "applying");
-  return { warnings: warning ? [warning] : [] };
+  const status = appliedStatus(issue, link.merged);
+  const warning = await syncSuggestionStateLabel(gh, n, issue.labels, status);
+  return { warnings: warning ? [warning] : [], status };
+}
+function appliedStatus(issue, merged) {
+  return merged || issue.state === "closed" && issue.stateReason === "completed" ? "applied" : "applying";
 }
 async function declineSuggestionOnGitHub(gh, n, reason, by) {
   const issue = await gh.getIssue(n);
@@ -6675,472 +7068,209 @@ async function switchToPublishedOnGitHub(gh, pr) {
   return { status: "switched", said: `Your branch now uses the published version from ${pull.baseRef}.` };
 }
 
-// ../core/src/token-proposal.ts
-var issueKey2 = (i) => `${i.code}|${i.path ?? ""}|${i.file ?? ""}|${i.message}`;
-function planTokenProposal(input) {
-  const { before, config } = input;
-  const r = applyTokenEdits(before, input.edits);
-  const after = new LayeredTokenSet(before.config, r.files);
-  const changes = diffLayered(before, after);
-  if (!changes.length) return null;
-  const prevErrors = new Set(validateLayered(before).map(issueKey2));
-  const newErrors = validateLayered(after).filter((i) => i.level === "error" && !prevErrors.has(issueKey2(i)));
-  const modes = config.contrast?.modes;
-  const contrast = input.pairs.length ? contrastDelta(runLayeredContrast(before, input.pairs, modes), runLayeredContrast(after, input.pairs, modes)) : [];
-  const newFailures = contrast.filter((d) => d.passBefore && !d.passAfter);
-  const impact = layeredImpact(before, after, changes);
-  const tier = classifyLayered(changes, [], config);
-  const summary2 = input.summary?.trim() || input.title;
-  const body = [composeProposalBody({ summary: summary2, changes, contrast, impact, tier, validationErrors: newErrors.length, tool: input.tool ?? "Bridge MCP" }), ...input.bodyExtra ?? []].filter(Boolean).join("\n\n");
-  const slug2 = slugify(input.title, 48) || "change";
-  const changesetPath = `${config.changesets?.dir ?? ".changeset"}/bridge-${slug2}.md`;
-  const touched = r.touched.map((f) => after.repoPath(f));
-  const files = [
-    ...r.touched.map((f) => ({ path: after.repoPath(f), content: after.files.get(f) })),
-    ...config.changesets ? [{ path: changesetPath, content: formatChangeset(config.changesets.package, tier.bump, summary2) }] : []
-  ];
-  const blocked = newErrors.length || newFailures.length ? [newErrors.length ? `${newErrors.length} new validation error(s)` : "", newFailures.length ? `${newFailures.length} contrast pair(s) would fail` : ""].filter(Boolean).join(" and ") : null;
-  return { title: input.title, summary: summary2, edits: input.edits, before, after, changes, tier, contrast, newFailures, newErrors, impact, notes: r.notes, touched, files, body, slug: slug2, blocked };
-}
-async function writeTokenProposalOnGitHub(gh, plan, opts) {
-  if (plan.blocked) throw new Error(`Not opened: ${plan.blocked}. Bridge never opens a branch that breaks the gate.`);
-  const jira = opts.jira ?? null;
-  let branch = branchWithJiraKey(`${opts.branchPrefix}${plan.slug}`, jira);
-  for (let i = 2; await gh.getBranchSha(branch).then(Boolean, () => false); i++) branch = branchWithJiraKey(`${opts.branchPrefix}${plan.slug}-${i}`, jira);
-  const commit = await gh.commitToNewBranch({ base: opts.base, branch, message: `feat(tokens): ${plan.title}
-
-Proposed through ${opts.tool ?? "Bridge MCP"}. Tier ${plan.tier.tier}.`, files: plan.files });
-  const labels = tokenLabels(plan, opts.labels, opts.labelsAfter);
-  const draft = plan.tier.tier >= 2;
-  const pr = await gh.createPullRequest({ base: opts.base, head: branch, title: titleWithJiraKey(`feat(tokens): ${plan.title}`, jira), body: plan.body, draft });
-  await gh.addLabels(pr.number, labels);
-  return { branch, commit: commit.sha, pr: pr.number, url: pr.url, labels, draft };
-}
-var tokenLabels = (plan, before = [], after = []) => [
-  .../* @__PURE__ */ new Set([...before, `tier: ${plan.tier.tier}`, ...plan.tier.tier === 3 ? ["tokens"] : [], ...plan.tier.bump === "major" ? ["breaking"] : [], ...after])
-];
-function tokenSuggestionPayload(plan, ctx) {
-  const tokenFiles = new Set(plan.touched);
-  const files = plan.files.filter((f) => !tokenFiles.has(f.path)).map((f) => ({ path: f.path, beforeSha: null, afterSha: f.content === null ? null : gitBlobSha(f.content), content: f.content }));
-  return {
-    schema: SUGGESTION_SCHEMA,
-    kind: "token-change",
-    title: plan.title,
-    summary: plan.summary,
-    source: ctx.source,
-    ...ctx.suggestedBy ? { suggestedBy: ctx.suggestedBy.replace(/^@/, "") } : {},
-    createdAt: ctx.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-    base: ctx.base,
-    tier: { tier: plan.tier.tier, bump: plan.tier.bump },
-    tokens: {
-      edits: plan.edits,
-      changes: plan.changes.map((c) => ({ kind: c.kind, path: c.path, from: c.from, file: c.file, before: c.before, after: c.after, beforeCss: c.beforeCss, afterCss: c.afterCss }))
-    },
-    ...files.length ? { files } : {},
-    checks: {
-      newErrors: plan.newErrors.length,
-      contrast: plan.contrast.map((d) => ({ pair: `${d.fg} on ${d.bg}`, mode: d.modes || void 0, before: d.before ?? 0, after: d.after ?? 0, min: d.min, pass: d.passAfter })),
-      blocked: plan.blocked,
-      impact: plan.impact.total
-    },
-    ...ctx.links ? { links: ctx.links } : {},
-    ...ctx.previews?.length ? { previews: ctx.previews } : {}
-  };
-}
-async function suggestTokenProposalOnGitHub(gh, plan, opts) {
-  if (plan.blocked) throw new Error(`Not suggested: ${plan.blocked}. Bridge never suggests a change that breaks the gate.`);
-  const sha = opts.baseSha ?? await gh.getBranchSha(opts.base);
-  if (!sha) throw new Error(`Branch ${opts.base} not found. Check the default branch in bridge.config.json.`);
-  const links = opts.neededBy || opts.links ? { ...opts.links, ...opts.neededBy ? { neededBy: opts.neededBy } : {} } : void 0;
-  const payload = tokenSuggestionPayload(plan, { base: { ref: opts.base, sha }, source: opts.source, suggestedBy: opts.suggestedBy, links, previews: opts.previews });
-  const labels = tokenLabels(plan, opts.labels, opts.labelsAfter);
-  const created = await createSuggestionOnGitHub(gh, payload, { labels, assignees: opts.assignees, details: plan.body });
-  return { status: "suggested", number: created.number, url: created.url, sha: created.sha, labels, warnings: created.warnings };
-}
-
-// ../core/src/figma-push-github.ts
-var pushSource = (d) => ["figma", "studio", "cli", "mcp"].includes(d.source) ? d.source : "figma";
-var specTier = (d) => ({ tier: 2, bump: d.kind === "new-component" || d.kind === "new-variant" || d.kind === "prop-change" ? "minor" : "patch" });
-function componentSpecSuggestionPayload(d, plan, ctx) {
-  const specPath = figmaSpecPath(d);
-  const spec = JSON.parse(formatFigmaSpec(d, plan));
-  const brief = figmaDraftBrief({ ...d, tokenEdits: plan.edits, reasons: plan.reasons }, { suggestion: true, specPath, componentsDir: ctx.componentsDir });
-  const by = (ctx.suggestedBy ?? d.requestedBy)?.replace(/^@/, "");
-  const figma = d.figma?.fileKey || d.figma?.nodeId || d.figma?.url ? { ...d.figma.fileKey ? { fileKey: d.figma.fileKey } : {}, ...d.figma.nodeId ? { nodeId: d.figma.nodeId } : {}, ...d.figma.url ? { url: d.figma.url } : {}, ...figmaNodes(d) } : void 0;
-  const previews = (d.images ?? []).map((url, i) => ({ label: `${d.component} in Figma${(d.images?.length ?? 0) > 1 ? ` ${i + 1}` : ""}`, url }));
-  return {
-    schema: SUGGESTION_SCHEMA,
-    kind: "component-spec",
-    title: d.title,
-    summary: d.summary.trim() || d.title,
-    source: pushSource(d),
-    ...by ? { suggestedBy: by } : {},
-    createdAt: ctx.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-    base: ctx.base,
-    tier: specTier(d),
-    componentSpec: { component: d.component, specPath, spec, brief },
-    checks: { newErrors: 0, contrast: [], blocked: null, impact: 0 },
-    ...figma ? { links: { figma } } : {},
-    ...previews.length ? { previews } : {}
-  };
-}
-function figmaNodes(d) {
-  const f = d.figma;
-  if (!f) return {};
-  const url = (id, given) => given ?? (f.fileKey ? figmaNodeUrl(f.fileKey, id) : void 0);
-  const nodes = [];
-  if (f.before?.nodeId) nodes.push({ nodeId: f.before.nodeId, state: "before", ...url(f.before.nodeId, f.before.url) ? { url: url(f.before.nodeId, f.before.url) } : {}, ...f.before.nodeName ? { name: f.before.nodeName } : {} });
-  if (f.nodeId) nodes.push({ nodeId: f.nodeId, state: "after", ...url(f.nodeId, f.url) ? { url: url(f.nodeId, f.url) } : {}, ...f.nodeName ? { name: f.nodeName } : {} });
-  return nodes.length ? { nodes } : {};
-}
-async function openComponentPushOnGitHub(gh, input) {
-  const d = input.diff;
-  if (!input.plan && !input.tokens) throw new Error("Route the change first: pass the token facts or the plan.");
-  const plan = input.plan ?? planComponentPush(d, input.tokens);
-  if (plan.route === "manual") return { status: "not-sent", plan, link: null };
-  if (input.dryRun) return { status: "dry-run", plan, link: null };
-  const mode = input.mode ?? "direct";
-  if (!gh.canWrite) throw new GitHubError(401, mode === "suggest" ? "Suggesting a component change needs a GitHub token (issues: write)." : "Sending a component change needs a GitHub token (contents and pull requests: write).");
-  const origin = {
-    component: d.component,
-    figmaName: d.figmaName,
-    route: plan.route,
-    kind: d.kind,
-    ...d.figma?.nodeId ? { nodeId: d.figma.nodeId } : {},
-    ...d.figma?.fileKey ? { fileKey: d.figma.fileKey } : {},
-    ...d.figma?.url ? { url: d.figma.url } : {},
-    ...d.requestedBy ? { requestedBy: d.requestedBy } : {}
-  };
-  if (plan.route === "token-change") {
-    if (!input.writeTokens) throw new GitHubError(422, "This change is a token change: send it where the token files are read (the DS Bridge plugin, bridge_push_figma_component or `bridge figma push`).");
-    const figma = { ...origin.fileKey ? { fileKey: origin.fileKey } : {}, ...origin.nodeId ? { nodeId: origin.nodeId } : {}, ...origin.url ? { url: origin.url } : {}, ...figmaNodes(d) };
-    const r = await input.writeTokens({ edits: plan.edits, title: figmaBranchTitle(d), summary: d.summary.trim() || d.title, bodyExtra: [figmaOriginSection(origin)], mode, figma });
-    await gh.addLabels(r.number, [FROM_FIGMA_LABEL]);
-    if (r.status === "suggested") return { status: "suggested", plan, link: null, suggestion: { route: "token-change", number: r.number, url: r.url } };
-    return { status: "opened", plan, link: { route: "token-change", number: r.number, url: r.url, branch: r.branch } };
-  }
-  if (mode === "suggest") {
-    const sha = input.baseSha ?? await gh.getBranchSha(input.base);
-    if (!sha) throw new GitHubError(404, `Branch ${input.base} not found. Check the default branch in bridge.config.json.`);
-    const payload = componentSpecSuggestionPayload(d, plan, { base: { ref: input.base, sha }, suggestedBy: input.suggestedBy });
-    const created = await createSuggestionOnGitHub(gh, payload, { labels: [...input.labels ?? [], WAITING_FOR_CLAUDE_LABEL] });
-    return { status: "suggested", plan, link: null, suggestion: { route: "claude-draft", number: created.number, url: created.url } };
-  }
-  const spec = figmaSpecPath(d);
-  const o = { ...origin, spec, status: "spec" };
-  let branch = `${input.branchPrefix}figma-${figmaSpecSlug(d)}`;
-  for (let i = 2; await gh.getBranchSha(branch).then(Boolean, () => false); i++) branch = `${input.branchPrefix}figma-${figmaSpecSlug(d)}-${i}`;
-  await gh.commitToNewBranch({
-    base: input.base,
-    branch,
-    message: `chore(figma): spec for ${figmaBranchTitle(d)}
-
-Sent from Figma with ${input.tool ?? "the DS Bridge Figma plugin"}. Claude AI drafts the code on this branch; a person reviews it.`,
-    files: [{ path: spec, content: formatFigmaSpec(d, plan) }]
-  });
-  const pr = await gh.createPullRequest({ base: input.base, head: branch, title: figmaBranchTitle(d), body: figmaDraftBody(d, plan, o), draft: true });
-  await gh.addLabels(pr.number, [.../* @__PURE__ */ new Set([...input.labels ?? [], FROM_FIGMA_LABEL, REQUEST_LABEL, WAITING_FOR_CLAUDE_LABEL])]);
-  return { status: "opened", plan, link: { route: "claude-draft", number: pr.number, url: pr.url, branch } };
-}
-async function listFigmaChangesOnGitHub(gh, opts = {}) {
-  const pulls = await gh.listPullRequests(opts.state ?? "open");
-  const out = [];
-  for (const p of pulls) {
-    if (!p.labels.includes(FROM_FIGMA_LABEL)) continue;
-    const origin = parseFigmaOrigin(p.body);
-    if (!origin) continue;
-    out.push({ number: p.number, title: p.title, url: p.url, branch: p.headRef, origin, status: figmaPushStatus({ state: p.state, draft: p.draft, labels: p.labels, route: origin.route }) });
-  }
-  return out;
-}
-async function figmaChangeOnGitHub(gh, n, opts = {}) {
-  const pull = await gh.getPullRequest(n);
-  const origin = parseFigmaOrigin(pull.body);
-  if (!origin) throw new GitHubError(404, `#${n} was not sent from Figma (no "From Figma" block in its description).`);
-  const status = figmaPushStatus({ state: pull.state, draft: pull.draft, labels: pull.labels, route: origin.route });
-  if (origin.route === "token-change") return { pull, origin, status, spec: void 0, brief: void 0 };
-  const text = origin.spec ? await gh.getFileText(origin.spec, pull.headSha).catch(() => void 0) : void 0;
-  const spec = parseFigmaSpec(text);
-  if (!spec) throw new GitHubError(404, `The spec ${origin.spec ?? FIGMA_SPEC_DIR} is missing from ${pull.headRef}. Send the component from Figma again.`);
-  const brief = figmaDraftBrief(spec, { pr: n, branch: pull.headRef, specPath: origin.spec, componentsDir: opts.componentsDir });
-  return { pull, origin, status, spec, brief };
-}
-async function markFigmaChangeDraftedOnGitHub(gh, n) {
-  if (!gh.canWrite) throw new GitHubError(401, "Marking a branch drafted needs a GitHub token (pull requests: write).");
-  const pull = await gh.getPullRequest(n);
-  const origin = parseFigmaOrigin(pull.body);
-  if (!origin || origin.route !== "claude-draft") throw new GitHubError(422, `#${n} is not a Claude draft branch from Figma.`);
-  if (pull.state !== "open") throw new GitHubError(422, `#${n} is ${pull.state}: only an open branch is marked drafted.`);
-  const files = (await gh.listPullRequestFiles(n)).map((f) => f.filename).filter((f) => !f.startsWith(`${FIGMA_SPEC_DIR}/`));
-  if (!files.length) throw new GitHubError(422, `${pull.headRef} only carries the spec: write the component code there first, push it, then mark it drafted.`);
-  await gh.updatePullRequest(n, { body: withFigmaOrigin(pull.body, { ...origin, status: "drafted" }) });
-  await gh.removeLabel(n, WAITING_FOR_CLAUDE_LABEL).catch(() => void 0);
-  await gh.addLabels(n, [DRAFTED_BY_CLAUDE_LABEL]);
-  const labels = [...pull.labels.filter((l) => l !== WAITING_FOR_CLAUDE_LABEL), DRAFTED_BY_CLAUDE_LABEL];
-  return { status: figmaPushStatus({ state: pull.state, labels, route: origin.route }), files };
-}
-
-// ../core/src/suggestion-apply.ts
-var SUGGESTION_APPLY_EXIT = {
-  ready: 0,
-  "already-applied": 0,
-  conflict: 3,
-  "not-approved": 1,
-  blocked: 1,
-  refused: 1
-};
-var same2 = (a, b) => canonicalJson(a) === canonicalJson(b);
-var show3 = (v) => v === void 0 ? "nothing" : typeof v === "string" ? v : JSON.stringify(v);
-function tokenRoot(config) {
-  const r = config.tokens.root.replace(/\/+$/, "");
-  return r === "." ? "" : r;
-}
-function tokenFileOf(config, path) {
-  const root = tokenRoot(config);
-  if (root && !path.startsWith(`${root}/`)) return null;
-  if (!selectTokenFiles(config, [path]).length) return null;
-  return root ? path.slice(root.length + 1) : path;
-}
-function planTokenEdit(set, e, changes) {
-  const base = { type: "token", path: e.path, edit: e, ...e.file ? { file: e.file } : {} };
-  const defsAt = (path) => set.defs.filter((d) => d.path === path && (!e.file || d.file === e.file));
-  const recorded = (file, path = e.path) => changes.find((c) => c.path === path && c.file === file && (e.op === "rename" ? c.kind === "renamed" : true));
-  const conflict = (detail, extra = {}) => ({ op: { ...base, state: "conflict", detail, ...extra }, notes: [] });
-  const done = (detail) => ({ op: { ...base, state: "already-applied", detail }, notes: [] });
-  let result;
-  try {
-    result = applyTokenEdits(set, [e]);
-  } catch (err) {
-    const why = err instanceof Error ? err.message : String(err);
-    switch (e.op) {
-      case "rename": {
-        const hasOld = defsAt(e.path).length > 0;
-        const hasNew = set.defs.some((d) => d.path === e.newPath);
-        if (!hasOld && hasNew) return done(`Already renamed to ${e.newPath}.`);
-        return conflict(hasOld && hasNew ? `Both ${e.path} and ${e.newPath} exist now: rename it by hand.` : `${e.path} no longer exists: ${why}`);
-      }
-      case "remove":
-        if (!defsAt(e.path).length) return done("Already removed.");
-        return conflict(why);
-      case "add": {
-        const existing = defsAt(e.path);
-        if (!existing.length) return conflict(why);
-        const want = (file) => {
-          const c = recorded(file);
-          if (c && c.after !== void 0) return c.after;
-          return coerceValue(e.value, e.type ?? existing.find((d2) => d2.file === file)?.type);
-        };
-        const all = existing.every((d2) => same2(d2.value, want(d2.file)));
-        if (all) return done("Already added with the suggested value.");
-        const d = existing.find((x) => !same2(x.value, want(x.file)));
-        return conflict(`Someone added ${e.path} with another value since.`, { file: d.file, after: want(d.file), now: d.value });
-      }
-      default:
-        return conflict(defsAt(e.path).length ? why : `${e.path} no longer exists, so its value cannot be set.`);
-    }
-  }
-  if (!result.touched.length) return done("Already has the suggested value.");
-  if (e.op === "set" || e.op === "remove" || e.op === "rename") {
-    for (const d of defsAt(e.path)) {
-      const c = recorded(d.file, e.op === "rename" ? e.newPath ?? e.path : e.path);
-      if (!c) continue;
-      const okNow = same2(d.value, c.before) || e.op === "set" && same2(d.value, c.after);
-      if (!okNow) return conflict(`${e.path} changed since it was suggested (now ${show3(d.value)}, suggested from ${show3(c.before)}).`, { file: d.file, before: c.before, after: c.after, now: d.value });
-    }
-  }
-  const verb = e.op === "set" ? "Set" : e.op === "add" ? "Add" : e.op === "remove" ? "Remove" : `Rename to ${e.newPath ?? ""}`;
-  return { op: { ...base, state: "apply", detail: `${verb} in ${result.touched.join(", ")}.` }, files: result.files, notes: result.notes };
-}
-async function planFile(ws, baseSha, f) {
-  const base = { type: "file", path: f.path };
-  const cur = await ws.read(f.path);
-  const curSha = cur?.sha ?? null;
-  const theirs = f.afterSha === null ? null : f.content ?? null;
-  if (curSha === f.afterSha) return { op: { ...base, state: "already-applied", detail: f.afterSha === null ? "Already deleted." : "Already has the suggested content." } };
-  if (curSha === f.beforeSha) return { op: { ...base, state: "apply", detail: f.afterSha === null ? "Delete it." : f.beforeSha === null ? "Create it." : "Replace it with the suggested content." }, content: theirs };
-  if (f.beforeSha === null) return { op: { ...base, state: "conflict", detail: "The suggestion creates this file, but a different one exists now." } };
-  if (!cur) return { op: { ...base, state: "conflict", detail: "The suggestion changes this file, but it was deleted since." } };
-  if (theirs === null) return { op: { ...base, state: "conflict", detail: "The suggestion deletes this file, but it changed since." } };
-  const original = await ws.readAt(baseSha, f.path);
-  if (original === null || gitBlobSha(original) !== f.beforeSha || !ws.merge) {
-    return { op: { ...base, state: "conflict", detail: original === null ? "The file changed since and its version at the suggestion base cannot be read, so it cannot be merged." : "The file changed since and cannot be merged here." } };
-  }
-  const merged = await ws.merge({ path: f.path, ours: cur.text, base: original, theirs });
-  if (!merged.clean) return { op: { ...base, state: "conflict", detail: `The file changed since and the merge has ${merged.conflicts} conflict(s).`, hunks: merged.conflicts } };
-  if (merged.text === cur.text) return { op: { ...base, state: "already-applied", detail: "Already has the suggested lines." } };
-  return { op: { ...base, state: "apply-merged", detail: "The file changed since: merged with the suggested lines, no conflict." }, content: merged.text };
-}
-async function planSuggestionApply(input) {
-  const { parsed, config, workspace: ws } = input;
-  const payload = parsed.payload;
-  const notes = [];
-  const out = (outcome, message, rest2 = {}) => ({
-    outcome,
-    exitCode: SUGGESTION_APPLY_EXIT[outcome],
-    message,
-    payloadSha: parsed.sha,
-    payload,
-    gate: null,
-    ops: [],
-    writes: [],
-    checks: null,
-    problems: [],
-    notes,
-    ...payload.componentSpec ? { brief: payload.componentSpec.brief } : {},
-    ...rest2
-  });
-  const problems = suggestionPathProblems(payload, config);
-  if (payload.checks.blocked) problems.push(`It was suggested with a failing check (${payload.checks.blocked}): ask the author to fix it and send it again.`);
-  for (const f of payload.files ?? []) {
-    if (f.afterSha !== null && typeof f.content !== "string") problems.push(`"${f.path}" has no content in the suggestion: it is incomplete, ask the author to send it again.`);
-    else if (f.afterSha !== null && gitBlobSha(f.content) !== f.afterSha) problems.push(`"${f.path}" does not match the content it was suggested with: someone edited it by hand.`);
-  }
-  if (problems.length) return out("refused", "Not applied: the suggestion asks for something Bridge never writes.", { problems: [...new Set(problems)] });
-  if (parsed.edited && !input.acceptEdited) {
-    return out("refused", 'Not applied: the suggestion was edited by hand since Bridge wrote it. Read the change, then apply it with "accept edited" if it is right.', {
-      problems: ["The payload no longer matches the sha Bridge recorded."]
-    });
-  }
-  const root = tokenRoot(config);
-  const tokenFiles = selectTokenFiles(config, await ws.list());
-  const targets = [
-    ...(payload.files ?? []).map((f) => f.path),
-    ...(payload.docs ?? []).map((d) => d.path),
-    ...payload.componentSpec ? [payload.componentSpec.specPath] : [],
-    ...payload.tokens?.edits.length ? tokenFiles.map((f) => root ? `${root}/${f}` : f) : []
-  ];
-  if (ws.isSymlink) {
-    const links = [];
-    for (const p of new Set(targets)) if (await ws.isSymlink(p)) links.push(`"${p}" is a symbolic link (or inside one): Bridge never writes through links.`);
-    if (links.length) return out("refused", "Not applied: the suggestion writes through a symbolic link.", { problems: links });
-  }
-  const governance = input.governance ?? { owners: config.governance.owners, rights: config.governance.rights ?? null, soloOwnerCanApproveBoth: config.governance.soloOwnerCanApproveBoth };
-  const approvals = summarizeSuggestionApprovals(input.comments, governance, { payloadSha: parsed.sha, author: input.author });
-  const review = suggestionReviewState(payload.tier.tier, approvals);
-  const missing = pendingApprovals(payload.tier.tier, approvals);
-  const approved = review === "approved";
-  const gate = { review, missing, approvals, forced: !approved && Boolean(input.forceUnapproved), edited: parsed.edited };
-  const ops = [];
-  const writes = /* @__PURE__ */ new Map();
-  const current = /* @__PURE__ */ new Map();
-  for (const f of tokenFiles) {
-    const r = await ws.read(root ? `${root}/${f}` : f);
-    if (r) current.set(f, r.text);
-  }
-  const before = new LayeredTokenSet(config, current);
-  let set = before;
-  const appliedEdits = [];
-  for (const e of payload.tokens?.edits ?? []) {
-    const r = planTokenEdit(set, e, payload.tokens.changes);
-    ops.push(r.op);
-    notes.push(...r.notes);
-    if (r.op.state === "apply" && r.files) {
-      set = new LayeredTokenSet(config, r.files);
-      appliedEdits.push(e);
-    }
-  }
-  for (const [f, text] of set.files) if (text !== before.files.get(f)) writes.set(set.repoPath(f), text);
-  for (const f of payload.files ?? []) {
-    if (writes.has(f.path)) {
-      notes.push(`${f.path}: the token edits write this file, its copy in the suggestion is not used.`);
-      continue;
-    }
-    const r = await planFile(ws, payload.base.sha, f);
-    ops.push(r.op);
-    if (r.op.state === "apply" || r.op.state === "apply-merged") writes.set(f.path, r.content ?? null);
-  }
-  for (const d of payload.docs ?? []) {
-    const base = { type: "docs", path: d.path };
-    const docs = d.after;
-    let text;
-    try {
-      const issues = validateDocs(docs);
-      if (issues.length) {
-        problems.push(`${d.path}: ${issues.map((i) => i.message).join(" ")}`);
-        continue;
-      }
-      const cur = await ws.read(d.path);
-      text = docsFileText(docs, cur?.text ?? null);
-      if (cur && text === cur.text) {
-        ops.push({ ...base, state: "already-applied", detail: "The docs already say this." });
-        continue;
-      }
-      ops.push({ ...base, state: "apply", detail: cur ? "Update the changed fields; other fields stay as they are now." : "Create the docs file." });
-      writes.set(d.path, text);
-    } catch (err) {
-      problems.push(`${d.path}: the suggested docs are not a docs.json Bridge can read (${err instanceof Error ? err.message : String(err)}).`);
-    }
-  }
-  if (payload.componentSpec) {
-    const s = payload.componentSpec;
-    const text = `${JSON.stringify(s.spec, null, 2)}
-`;
-    const cur = await ws.read(s.specPath);
-    if (cur && cur.text === text) ops.push({ type: "component-spec", path: s.specPath, state: "already-applied", detail: "The spec file is already there." });
-    else {
-      ops.push({ type: "component-spec", path: s.specPath, state: "apply", detail: `Write the spec; the ${s.component} code itself is written from the brief.` });
-      writes.set(s.specPath, text);
-    }
-  }
-  const afterFiles = new Map(set.files);
-  for (const [p, content] of writes) {
-    const tf = tokenFileOf(config, p);
-    if (!tf) continue;
-    if (content === null) afterFiles.delete(tf);
-    else afterFiles.set(tf, content);
-  }
-  const after = new LayeredTokenSet(config, afterFiles);
-  const tokenChanges = diffLayered(before, after);
-  const issueKey4 = (i) => `${i.code}|${i.path ?? ""}|${i.file ?? ""}|${i.message}`;
-  const prevErrors = new Set(validateLayered(before).map(issueKey4));
-  const newErrors = tokenChanges.length ? validateLayered(after).filter((i) => i.level === "error" && !prevErrors.has(issueKey4(i))) : [];
-  let pairs = [];
-  if (config.contrast && tokenChanges.length) {
-    try {
-      pairs = parseContrastChecks((await ws.read(config.contrast.path))?.text);
-    } catch {
-      notes.push(`${config.contrast.path} does not parse: contrast was not checked.`);
-    }
-  }
+// ../core/src/token-proposal.ts
+var issueKey2 = (i) => `${i.code}|${i.path ?? ""}|${i.file ?? ""}|${i.message}`;
+function planTokenProposal(input) {
+  const { before, config } = input;
+  const r = applyTokenEdits(before, input.edits);
+  const after = new LayeredTokenSet(before.config, r.files);
+  const changes = diffLayered(before, after);
+  if (!changes.length) return null;
+  const prevErrors = new Set(validateLayered(before).map(issueKey2));
+  const newErrors = validateLayered(after).filter((i) => i.level === "error" && !prevErrors.has(issueKey2(i)));
   const modes = config.contrast?.modes;
-  const contrast = pairs.length ? contrastDelta(runLayeredContrast(before, pairs, modes), runLayeredContrast(after, pairs, modes)) : [];
+  const contrast = input.pairs.length ? contrastDelta(runLayeredContrast(before, input.pairs, modes), runLayeredContrast(after, input.pairs, modes)) : [];
   const newFailures = contrast.filter((d) => d.passBefore && !d.passAfter);
-  const otherFiles = [...writes.keys()].filter((p) => !tokenFileOf(config, p));
-  const tier = classifyRisk({ tokenChanges: tokenChanges.map((c) => ({ kind: c.kind, path: c.path, ...c.kind === "changed" ? { descriptionOnly: c.fields.length > 0 && c.fields.every((x) => x === "description") } : {} })), files: otherFiles.map((path) => ({ path })), config });
-  const tierIncreased = writes.size > 0 && tier.tier > payload.tier.tier;
-  const checks = { tierWhenSuggested: payload.tier.tier, tier, tierIncreased, newErrors, newFailures, contrast, tokenChanges };
-  const rest = { gate, ops, checks, problems };
-  if (problems.length) return out("refused", "Not applied: part of the suggestion is not valid.", rest);
-  const conflicts = ops.filter((o) => o.state === "conflict");
-  if (conflicts.length) {
-    return out("conflict", `Not applied: ${conflicts.length} change(s) conflict with the code now. Ask the author to refresh the suggestion on today's code, or apply those parts by hand.`, rest);
-  }
-  if (!writes.size) return out("already-applied", "Already applied: the code has every change of this suggestion.", rest);
-  if (newErrors.length || newFailures.length) {
-    const why = [newErrors.length ? `${newErrors.length} new validation error(s)` : "", newFailures.length ? `${newFailures.length} contrast pair(s) would fail` : ""].filter(Boolean).join(" and ");
-    return out("blocked", `Not applied: on today's code it would add ${why}. Ask the author to refresh the suggestion.`, rest);
-  }
-  if (tierIncreased && !input.forceUnapproved) {
-    return out("blocked", `Not applied: on today's code it is a tier ${tier.tier} change, it was approved as tier ${payload.tier.tier}. It needs a new approval.`, rest);
+  const impact = layeredImpact(before, after, changes);
+  const tier = classifyLayered(changes, [], config);
+  const summary2 = input.summary?.trim() || input.title;
+  const body = [composeProposalBody({ summary: summary2, changes, contrast, impact, tier, validationErrors: newErrors.length, tool: input.tool ?? "Bridge MCP" }), ...input.bodyExtra ?? []].filter(Boolean).join("\n\n");
+  const slug2 = slugify(input.title, 48) || "change";
+  const changesetPath = `${config.changesets?.dir ?? ".changeset"}/bridge-${slug2}.md`;
+  const touched = r.touched.map((f) => after.repoPath(f));
+  const files = [
+    ...r.touched.map((f) => ({ path: after.repoPath(f), content: after.files.get(f) })),
+    ...config.changesets ? [{ path: changesetPath, content: formatChangeset(config.changesets.package, tier.bump, summary2) }] : []
+  ];
+  const blocked = newErrors.length || newFailures.length ? [newErrors.length ? `${newErrors.length} new validation error(s)` : "", newFailures.length ? `${newFailures.length} contrast pair(s) would fail` : ""].filter(Boolean).join(" and ") : null;
+  return { title: input.title, summary: summary2, edits: input.edits, before, after, changes, tier, contrast, newFailures, newErrors, impact, notes: r.notes, touched, files, body, slug: slug2, blocked };
+}
+async function writeTokenProposalOnGitHub(gh, plan, opts) {
+  if (plan.blocked) throw new Error(`Not opened: ${plan.blocked}. Bridge never opens a branch that breaks the gate.`);
+  const jira = opts.jira ?? null;
+  let branch = branchWithJiraKey(`${opts.branchPrefix}${plan.slug}`, jira);
+  for (let i = 2; await gh.getBranchSha(branch).then(Boolean, () => false); i++) branch = branchWithJiraKey(`${opts.branchPrefix}${plan.slug}-${i}`, jira);
+  const commit = await gh.commitToNewBranch({ base: opts.base, branch, message: `feat(tokens): ${plan.title}
+
+Proposed through ${opts.tool ?? "Bridge MCP"}. Tier ${plan.tier.tier}.`, files: plan.files });
+  const labels = tokenLabels(plan, opts.labels, opts.labelsAfter);
+  const draft = plan.tier.tier >= 2;
+  const pr = await gh.createPullRequest({ base: opts.base, head: branch, title: titleWithJiraKey(`feat(tokens): ${plan.title}`, jira), body: plan.body, draft });
+  await gh.addLabels(pr.number, labels);
+  return { branch, commit: commit.sha, pr: pr.number, url: pr.url, labels, draft };
+}
+var tokenLabels = (plan, before = [], after = []) => [
+  .../* @__PURE__ */ new Set([...before, `tier: ${plan.tier.tier}`, ...plan.tier.tier === 3 ? ["tokens"] : [], ...plan.tier.bump === "major" ? ["breaking"] : [], ...after])
+];
+function tokenSuggestionPayload(plan, ctx) {
+  const tokenFiles = new Set(plan.touched);
+  const files = plan.files.filter((f) => !tokenFiles.has(f.path)).map((f) => ({ path: f.path, beforeSha: null, afterSha: f.content === null ? null : gitBlobSha(f.content), content: f.content }));
+  return {
+    schema: SUGGESTION_SCHEMA,
+    kind: "token-change",
+    title: plan.title,
+    summary: plan.summary,
+    source: ctx.source,
+    ...ctx.suggestedBy ? { suggestedBy: ctx.suggestedBy.replace(/^@/, "") } : {},
+    createdAt: ctx.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    base: ctx.base,
+    tier: { tier: plan.tier.tier, bump: plan.tier.bump },
+    tokens: {
+      edits: plan.edits,
+      changes: plan.changes.map((c) => ({ kind: c.kind, path: c.path, from: c.from, file: c.file, before: c.before, after: c.after, beforeCss: c.beforeCss, afterCss: c.afterCss }))
+    },
+    ...files.length ? { files } : {},
+    checks: {
+      newErrors: plan.newErrors.length,
+      contrast: plan.contrast.map((d) => ({ pair: `${d.fg} on ${d.bg}`, mode: d.modes || void 0, before: d.before ?? 0, after: d.after ?? 0, min: d.min, pass: d.passAfter })),
+      blocked: plan.blocked,
+      impact: plan.impact.total
+    },
+    ...ctx.links ? { links: ctx.links } : {},
+    ...ctx.previews?.length ? { previews: ctx.previews } : {}
+  };
+}
+async function suggestTokenProposalOnGitHub(gh, plan, opts) {
+  if (plan.blocked) throw new Error(`Not suggested: ${plan.blocked}. Bridge never suggests a change that breaks the gate.`);
+  const sha = opts.baseSha ?? await gh.getBranchSha(opts.base);
+  if (!sha) throw new Error(`Branch ${opts.base} not found. Check the default branch in bridge.config.json.`);
+  const links = opts.neededBy || opts.links ? { ...opts.links, ...opts.neededBy ? { neededBy: opts.neededBy } : {} } : void 0;
+  const payload = tokenSuggestionPayload(plan, { base: { ref: opts.base, sha }, source: opts.source, suggestedBy: opts.suggestedBy, links, previews: opts.previews });
+  const labels = tokenLabels(plan, opts.labels, opts.labelsAfter);
+  const created = await createSuggestionOnGitHub(gh, payload, { labels, assignees: opts.assignees, details: plan.body });
+  return { status: "suggested", number: created.number, url: created.url, sha: created.sha, labels, warnings: created.warnings };
+}
+
+// ../core/src/figma-push-github.ts
+var pushSource = (d) => ["figma", "studio", "cli", "mcp"].includes(d.source) ? d.source : "figma";
+var specTier = (d) => ({ tier: 2, bump: d.kind === "new-component" || d.kind === "new-variant" || d.kind === "prop-change" ? "minor" : "patch" });
+function componentSpecSuggestionPayload(d, plan, ctx) {
+  const specPath = figmaSpecPath(d);
+  const spec = JSON.parse(formatFigmaSpec(d, plan));
+  const brief = figmaDraftBrief({ ...d, tokenEdits: plan.edits, reasons: plan.reasons }, { suggestion: true, specPath, componentsDir: ctx.componentsDir });
+  const by = (ctx.suggestedBy ?? d.requestedBy)?.replace(/^@/, "");
+  const figma = d.figma?.fileKey || d.figma?.nodeId || d.figma?.url ? { ...d.figma.fileKey ? { fileKey: d.figma.fileKey } : {}, ...d.figma.nodeId ? { nodeId: d.figma.nodeId } : {}, ...d.figma.url ? { url: d.figma.url } : {}, ...figmaNodes(d) } : void 0;
+  const previews = (d.images ?? []).map((url, i) => ({ label: `${d.component} in Figma${(d.images?.length ?? 0) > 1 ? ` ${i + 1}` : ""}`, url }));
+  return {
+    schema: SUGGESTION_SCHEMA,
+    kind: "component-spec",
+    title: d.title,
+    summary: d.summary.trim() || d.title,
+    source: pushSource(d),
+    ...by ? { suggestedBy: by } : {},
+    createdAt: ctx.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    base: ctx.base,
+    tier: specTier(d),
+    componentSpec: { component: d.component, specPath, spec, brief },
+    checks: { newErrors: 0, contrast: [], blocked: null, impact: 0 },
+    ...figma ? { links: { figma } } : {},
+    ...previews.length ? { previews } : {}
+  };
+}
+function figmaNodes(d) {
+  const f = d.figma;
+  if (!f) return {};
+  const url = (id, given) => given ?? (f.fileKey ? figmaNodeUrl(f.fileKey, id) : void 0);
+  const nodes = [];
+  if (f.before?.nodeId) nodes.push({ nodeId: f.before.nodeId, state: "before", ...url(f.before.nodeId, f.before.url) ? { url: url(f.before.nodeId, f.before.url) } : {}, ...f.before.nodeName ? { name: f.before.nodeName } : {} });
+  if (f.nodeId) nodes.push({ nodeId: f.nodeId, state: "after", ...url(f.nodeId, f.url) ? { url: url(f.nodeId, f.url) } : {}, ...f.nodeName ? { name: f.nodeName } : {} });
+  return nodes.length ? { nodes } : {};
+}
+async function openComponentPushOnGitHub(gh, input) {
+  const d = input.diff;
+  if (!input.plan && !input.tokens) throw new Error("Route the change first: pass the token facts or the plan.");
+  const plan = input.plan ?? planComponentPush(d, input.tokens);
+  if (plan.route === "manual") return { status: "not-sent", plan, link: null };
+  if (input.dryRun) return { status: "dry-run", plan, link: null };
+  const mode = input.mode ?? "direct";
+  if (!gh.canWrite) throw new GitHubError(401, mode === "suggest" ? "Suggesting a component change needs a GitHub token (issues: write)." : "Sending a component change needs a GitHub token (contents and pull requests: write).");
+  const origin = {
+    component: d.component,
+    figmaName: d.figmaName,
+    route: plan.route,
+    kind: d.kind,
+    ...d.figma?.nodeId ? { nodeId: d.figma.nodeId } : {},
+    ...d.figma?.fileKey ? { fileKey: d.figma.fileKey } : {},
+    ...d.figma?.url ? { url: d.figma.url } : {},
+    ...d.requestedBy ? { requestedBy: d.requestedBy } : {}
+  };
+  if (plan.route === "token-change") {
+    if (!input.writeTokens) throw new GitHubError(422, "This change is a token change: send it where the token files are read (the DS Bridge plugin, bridge_push_figma_component or `bridge figma push`).");
+    const figma = { ...origin.fileKey ? { fileKey: origin.fileKey } : {}, ...origin.nodeId ? { nodeId: origin.nodeId } : {}, ...origin.url ? { url: origin.url } : {}, ...figmaNodes(d) };
+    const r = await input.writeTokens({ edits: plan.edits, title: figmaBranchTitle(d), summary: d.summary.trim() || d.title, bodyExtra: [figmaOriginSection(origin)], mode, figma });
+    await gh.addLabels(r.number, [FROM_FIGMA_LABEL]);
+    if (r.status === "suggested") return { status: "suggested", plan, link: null, suggestion: { route: "token-change", number: r.number, url: r.url } };
+    return { status: "opened", plan, link: { route: "token-change", number: r.number, url: r.url, branch: r.branch } };
   }
-  if (!approved && !input.forceUnapproved) {
-    const who = review === "changes-requested" ? `changes requested by ${approvals.changesRequested.map((l) => `@${l}`).join(", ")}` : `missing ${missing.map((m) => m === "approval" ? "an approval" : `${m} approval`).join(" and ")}`;
-    return out("not-approved", `Not applied: it is not approved yet (${who}). Ask the owners to review it on the issue.`, rest);
+  if (mode === "suggest") {
+    const sha = input.baseSha ?? await gh.getBranchSha(input.base);
+    if (!sha) throw new GitHubError(404, `Branch ${input.base} not found. Check the default branch in bridge.config.json.`);
+    const payload = componentSpecSuggestionPayload(d, plan, { base: { ref: input.base, sha }, suggestedBy: input.suggestedBy });
+    const created = await createSuggestionOnGitHub(gh, payload, { labels: [...input.labels ?? [], WAITING_FOR_CLAUDE_LABEL] });
+    return { status: "suggested", plan, link: null, suggestion: { route: "claude-draft", number: created.number, url: created.url } };
   }
-  const forced = gate.forced || tierIncreased && Boolean(input.forceUnapproved);
-  return out("ready", `Ready: ${writes.size} file(s) to write${forced ? ", without every approval" : ""}.`, {
-    ...rest,
-    gate: { ...gate, forced },
-    writes: [...writes].map(([path, content]) => ({ path, content })).sort((a, b) => a.path.localeCompare(b.path))
+  const spec = figmaSpecPath(d);
+  const o = { ...origin, spec, status: "spec" };
+  let branch = `${input.branchPrefix}figma-${figmaSpecSlug(d)}`;
+  for (let i = 2; await gh.getBranchSha(branch).then(Boolean, () => false); i++) branch = `${input.branchPrefix}figma-${figmaSpecSlug(d)}-${i}`;
+  await gh.commitToNewBranch({
+    base: input.base,
+    branch,
+    message: `chore(figma): spec for ${figmaBranchTitle(d)}
+
+Sent from Figma with ${input.tool ?? "the DS Bridge Figma plugin"}. Claude AI drafts the code on this branch; a person reviews it.`,
+    files: [{ path: spec, content: formatFigmaSpec(d, plan) }]
   });
+  const pr = await gh.createPullRequest({ base: input.base, head: branch, title: figmaBranchTitle(d), body: figmaDraftBody(d, plan, o), draft: true });
+  await gh.addLabels(pr.number, [.../* @__PURE__ */ new Set([...input.labels ?? [], FROM_FIGMA_LABEL, REQUEST_LABEL, WAITING_FOR_CLAUDE_LABEL])]);
+  return { status: "opened", plan, link: { route: "claude-draft", number: pr.number, url: pr.url, branch } };
 }
-function suggestionAppliedComment(plan, where2) {
-  return composeSuggestionAppliedComment({ ...where2, payloadSha: plan.payloadSha, ...plan.gate?.forced ? { forced: true } : {} });
+async function listFigmaChangesOnGitHub(gh, opts = {}) {
+  const pulls = await gh.listPullRequests(opts.state ?? "open");
+  const out = [];
+  for (const p of pulls) {
+    if (!p.labels.includes(FROM_FIGMA_LABEL)) continue;
+    const origin = parseFigmaOrigin(p.body);
+    if (!origin) continue;
+    out.push({ number: p.number, title: p.title, url: p.url, branch: p.headRef, origin, status: figmaPushStatus({ state: p.state, draft: p.draft, labels: p.labels, route: origin.route }) });
+  }
+  return out;
 }
-function suggestionApplyTable(plan) {
-  const label = { "already-applied": "already applied", apply: "apply", "apply-merged": "apply (merged)", conflict: "**conflict**" };
-  const cell4 = (s) => s.replace(/\|/g, "\\|").replace(/\r?\n/g, " ");
-  return ["| Change | Result | Detail |", "| --- | --- | --- |", ...plan.ops.map((o) => `| \`${cell4(o.path)}\` | ${label[o.state]} | ${cell4(o.detail)} |`)].join("\n");
+async function figmaChangeOnGitHub(gh, n, opts = {}) {
+  const pull = await gh.getPullRequest(n);
+  const origin = parseFigmaOrigin(pull.body);
+  if (!origin) throw new GitHubError(404, `#${n} was not sent from Figma (no "From Figma" block in its description).`);
+  const status = figmaPushStatus({ state: pull.state, draft: pull.draft, labels: pull.labels, route: origin.route });
+  if (origin.route === "token-change") return { pull, origin, status, spec: void 0, brief: void 0 };
+  const text = origin.spec ? await gh.getFileText(origin.spec, pull.headSha).catch(() => void 0) : void 0;
+  const spec = parseFigmaSpec(text);
+  if (!spec) throw new GitHubError(404, `The spec ${origin.spec ?? FIGMA_SPEC_DIR} is missing from ${pull.headRef}. Send the component from Figma again.`);
+  const brief = figmaDraftBrief(spec, { pr: n, branch: pull.headRef, specPath: origin.spec, componentsDir: opts.componentsDir });
+  return { pull, origin, status, spec, brief };
+}
+async function markFigmaChangeDraftedOnGitHub(gh, n) {
+  if (!gh.canWrite) throw new GitHubError(401, "Marking a branch drafted needs a GitHub token (pull requests: write).");
+  const pull = await gh.getPullRequest(n);
+  const origin = parseFigmaOrigin(pull.body);
+  if (!origin || origin.route !== "claude-draft") throw new GitHubError(422, `#${n} is not a Claude draft branch from Figma.`);
+  if (pull.state !== "open") throw new GitHubError(422, `#${n} is ${pull.state}: only an open branch is marked drafted.`);
+  const files = (await gh.listPullRequestFiles(n)).map((f) => f.filename).filter((f) => !f.startsWith(`${FIGMA_SPEC_DIR}/`));
+  if (!files.length) throw new GitHubError(422, `${pull.headRef} only carries the spec: write the component code there first, push it, then mark it drafted.`);
+  await gh.updatePullRequest(n, { body: withFigmaOrigin(pull.body, { ...origin, status: "drafted" }) });
+  await gh.removeLabel(n, WAITING_FOR_CLAUDE_LABEL).catch(() => void 0);
+  await gh.addLabels(n, [DRAFTED_BY_CLAUDE_LABEL]);
+  const labels = [...pull.labels.filter((l) => l !== WAITING_FOR_CLAUDE_LABEL), DRAFTED_BY_CLAUDE_LABEL];
+  return { status: figmaPushStatus({ state: pull.state, labels, route: origin.route }), files };
 }
 
 // ../core/src/node/git-history.ts
@@ -10424,21 +10554,7 @@ async function branchFacts(ctx, gh, n, viewer) {
   const product = productOfBranch(productsOf(config), { files: files.map((f) => f.filename), labels: pr.labels });
   return { config, pr, files, ci, approvals, tier, gate, status, fresh, compare, exploration, product, lifecycle: pullState(pullLike), write: repo ? hasWriteAccess(repo.permissions) : null, repo, solo: who.solo };
 }
-var STATUS_WORDS = {
-  merged: "Merged",
-  closed: "Closed",
-  draft: "Draft",
-  "ci-failing": "Blocked by tests",
-  "changes-requested": "Changes requested",
-  "ci-running": "Tests running",
-  "needs-design": "Needs design approval",
-  "needs-tech": "Needs tech approval",
-  "needs-approval": "Needs approval",
-  conflict: "Conflict with main",
-  checking: "Checking",
-  ready: "Ready to merge",
-  unknown: "Status unknown"
-};
+var STATUS_WORDS = REVIEW_STATUS_LABEL;
 async function branchStatus(ctx, a) {
   const n = branchNumber(a.pr);
   const gh = await reader(ctx);
@@ -10454,7 +10570,7 @@ async function branchStatus(ctx, a) {
     status: { kind: f.status, label: STATUS_WORDS[f.status] },
     approvalNeeded: f.tier === 1 ? "One approval" : "Design and tech approval",
     approvals: { approvedBy: f.approvals.approvers, changesRequestedBy: f.approvals.changesRequested, design: f.approvals.design, tech: f.approvals.tech, ...f.solo && (f.tier ?? 3) > 1 ? { soloOwner: soloOwnerSentence(f.solo, Boolean(viewer && viewer.toLowerCase() === f.solo)) } : {} },
-    tests: { state: f.ci.state, failing: f.ci.failed.map((x) => x.name), running: f.ci.pending.map((x) => x.name) },
+    tests: { state: f.ci.state, label: CI_STATE_LABEL[f.ci.state], failing: f.ci.failed.map((x) => x.name), running: f.ci.pending.map((x) => x.name) },
     main: { state: f.fresh.state, behindBy: f.fresh.behindBy },
     merge: {
       allowed: f.gate.allowed,
@@ -10502,6 +10618,7 @@ async function whatNeedsMe(ctx, a = {}) {
         else if (f.status === "conflict") needsYou = "Your branch conflicts with main";
         else if (f.status === "ready" && f.gate.canShip) needsYou = "Your branch is ready to merge";
       }
+      if (viewer && !needsYou && f.gate.overridable && !reviewersToAsk({ tier: f.tier, approvals: f.approvals, owners: who.lists, author: p.author, viewer }).length) needsYou = "Only the owner override can merge it";
       return { pr: p.number, title: p.title, url: p.url, author: p.author, product: f.product.name, status: f.status, statusLabel: STATUS_WORDS[f.status], yours: mine, needsYou };
     })
   );
@@ -10673,6 +10790,7 @@ async function listComments(ctx, a) {
     howToReply: "bridge_comment with replyTo: the thread id."
   };
 }
+var appliedLine = (ns) => ns.length ? ` ${ns.length === 1 ? "Suggestion" : "Suggestions"} ${ns.map((x) => `#${x}`).join(", ")} ${ns.length === 1 ? "is" : "are"} marked applied.` : "";
 async function mergeBranch(ctx, a) {
   const n = branchNumber(a.pr);
   const gh = await writer(ctx, "Merging a branch", RIGHTS.merge);
@@ -10684,7 +10802,8 @@ async function mergeBranch(ctx, a) {
   if (f.gate.allowed) {
     if (a.dryRun) return { pr: n, status: "would-merge", said: "Every rule passes: it can be merged." };
     const r = await mergeOnGitHub(gh, { number: n, headSha: f.pr.headSha, method: "squash" });
-    return { pr: n, status: "merged", sha: r.sha, said: "Merged. It goes out with the next library release." };
+    const s = await markSuggestionsAppliedOnGitHub(gh, f.pr);
+    return { pr: n, status: "merged", sha: r.sha, said: `Merged. It goes out with the next library release.${appliedLine(s.applied)}`, ...s.warnings.length ? { warnings: s.warnings } : {} };
   }
   if (!reason) {
     const hint = f.gate.overridable ? ` Only approvals are missing and @${viewer} may use the owner override: pass overrideReason (at least ${policy.minReasonLength} characters), it is posted on the branch.` : "";
@@ -10698,7 +10817,8 @@ async function mergeBranch(ctx, a) {
   const method = allowedMergeMethods(f.repo)[0] ?? "squash";
   try {
     const r = await overrideMergeOnGitHub(gh, { number: n, headSha: f.pr.headSha, login: viewer, reason, missing: f.gate.missing, method });
-    return { pr: n, status: "merged", override: true, sha: r.sha, reasonUrl: r.commentUrl, said: `Merged as owner override. The reason is on #${n}.` };
+    const s = await markSuggestionsAppliedOnGitHub(gh, f.pr);
+    return { pr: n, status: "merged", override: true, sha: r.sha, reasonUrl: r.commentUrl, said: `Merged as owner override. The reason is on #${n}.${appliedLine(s.applied)}`, ...s.warnings.length ? { warnings: s.warnings } : {} };
   } catch (err) {
     if (err instanceof OverrideMergeError) throw new Error(err.message);
     throw err;
@@ -11067,11 +11187,33 @@ async function suggestionGovernance(ctx, gh) {
   return { config, gov: { owners, rights: rights ?? null, ...teams ? { teams } : {}, ...config.governance.soloOwnerCanApproveBoth ? { soloOwnerCanApproveBoth: true } : {} } };
 }
 var OPEN_STATUSES = ["needs-review", "changes-requested", "approved", "applying", "outdated"];
+var REVIEW_STATUSES = ["needs-review", "changes-requested", "approved"];
+var MAX_STALENESS_READS = 30;
+var mainRef = (ctx, config) => ctx.ref ?? baseBranchOf(config);
+async function stalenessOf(ctx, gh, d, config, gov) {
+  if (d.issue.state !== "open" || !REVIEW_STATUSES.includes(d.status)) return null;
+  return suggestionStalenessOnGitHub(gh, d, { config, governance: gov, ref: mainRef(ctx, config) }).catch(() => null);
+}
 async function listSuggestionsOp(ctx, a = {}) {
   const gh = await reader(ctx);
   const status = a.status ?? "all";
   const state = a.state ?? (status === "all" ? "open" : OPEN_STATUSES.includes(status) ? "open" : "closed");
-  let rows = await listSuggestionsOnGitHub(gh, { state, perPage: 100 });
+  const pulls = await gh.listPullRequests("all").catch(() => []);
+  let rows = await listSuggestionsOnGitHub(gh, { state, perPage: 100, pulls });
+  const open = rows.filter((r) => r.state === "open" && REVIEW_STATUSES.includes(r.status)).slice(0, MAX_STALENESS_READS);
+  if (open.length) {
+    const { config, gov } = await suggestionGovernance(ctx, gh);
+    const outdated = /* @__PURE__ */ new Set();
+    await Promise.all(
+      open.map(async (r) => {
+        const d = await getSuggestionOnGitHub(gh, r.number, gov, { pulls }).catch(() => null);
+        if (!d?.parsed.ok) return;
+        const st = await suggestionStalenessOnGitHub(gh, d, { config, governance: gov, ref: mainRef(ctx, config) }).catch(() => null);
+        if (st?.outdated) outdated.add(r.number);
+      })
+    );
+    rows = rows.map((r) => outdated.has(r.number) ? { ...r, status: stalenessStatus(r.status, { outdated: true }) } : r);
+  }
   if (status !== "all") rows = rows.filter((r) => r.status === status);
   if (a.kind) rows = rows.filter((r) => r.kind === a.kind);
   const total = rows.length;
@@ -11101,8 +11243,10 @@ var roleText = (m) => m === "approval" ? "one approval" : `${m} approval`;
 async function getSuggestionOp(ctx, a) {
   const n = suggestionNumber(a.number);
   const gh = await reader(ctx);
-  const { gov } = await suggestionGovernance(ctx, gh);
+  const { config, gov } = await suggestionGovernance(ctx, gh);
   const d = await getSuggestionOnGitHub(gh, n, gov);
+  const stale = d.parsed.ok ? await stalenessOf(ctx, gh, d, config, gov) : null;
+  d.status = stalenessStatus(d.status, stale);
   const base = { number: n, url: d.issue.url, title: d.issue.title, state: d.issue.state, status: d.status, said: SUGGESTION_STATUS_LABEL[d.status], author: d.issue.author, labels: d.issue.labels, linkedPrs: d.linkedPrs };
   if (!d.parsed.ok) {
     if (!d.issue.labels.includes(SUGGESTION_LABEL) && d.parsed.reason === "no-block") throw new Error(`Issue #${n} is not a Bridge suggestion: it has no "${SUGGESTION_LABEL}" label and no suggestion block.`);
@@ -11143,8 +11287,9 @@ async function getSuggestionOp(ctx, a) {
       ...solo && p.tier.tier > 1 ? { soloOwner: soloOwnerSentence(solo) } : {}
     },
     applied: d.applied,
+    ...stale?.outdated ? { outdated: { mainSha: stale.mainSha, conflicts: stale.conflicts.map((c) => ({ path: c.path, detail: c.detail })) } } : {},
     ...p.componentSpec ? { brief: p.componentSpec.brief } : {},
-    next: d.status === "approved" ? `Approved. Apply it: bridge_apply_suggestion { number: ${n}, mode: "dry-run" } first, then mode "branch" (or \`bridge apply ${n}\`). The pull request must say "Closes #${n}".` : d.status === "needs-review" ? `Waiting for ${missing.map(roleText).join(" and ") || "a review"} from the owners in ${CONFIG_FILE}: bridge_review_suggestion { number: ${n}, event: "approve" }.` : d.status === "changes-requested" ? "Changes requested: the author sends a new version (approvals then start again)." : d.status === "applying" ? `Being applied${d.linkedPrs.length ? ` in ${d.linkedPrs.map((x) => `#${x.number}`).join(", ")}` : ""}. It closes when the pull request merges.` : d.status === "outdated" ? "Outdated: the code changed since it was suggested. Ask the author to refresh it." : `${SUGGESTION_STATUS_LABEL[d.status]}: nothing to do.`
+    next: d.status === "approved" ? `Approved. Apply it: bridge_apply_suggestion { number: ${n}, mode: "dry-run" } first, then mode "branch" (or \`bridge apply ${n}\`). The pull request must say "Closes #${n}".` : d.status === "needs-review" ? `Waiting for ${missing.map(roleText).join(" and ") || "a review"} from the owners in ${CONFIG_FILE}: bridge_review_suggestion { number: ${n}, event: "approve" }.` : d.status === "changes-requested" ? "Changes requested: the author sends a new version (approvals then start again)." : d.status === "applying" ? `Being applied${d.linkedPrs.length ? ` in ${d.linkedPrs.map((x) => `#${x.number}`).join(", ")}` : ""}. It closes when the pull request merges.` : d.status === "outdated" ? `Outdated: ${stale?.conflicts[0] ? stale.conflicts[0].detail.replace(/\.$/, "") : "main changed what it changes since it was suggested"}. Ask the author to send it again on today's code.` : `${SUGGESTION_STATUS_LABEL[d.status]}: nothing to do.`
   };
 }
 async function reviewSuggestionOp(ctx, a) {
@@ -11187,12 +11332,7 @@ async function reviewSuggestionOp(ctx, a) {
   };
 }
 function githubWorkspace(gh, ref) {
-  let files;
-  return {
-    read: async (path) => await gh.getFile(path, ref) ?? null,
-    readAt: async (sha, path) => await gh.readFile(path, sha).catch(() => void 0) ?? null,
-    list: () => files ??= gh.listFiles(ref)
-  };
+  return githubSuggestionWorkspace(gh, ref);
 }
 var MAX_DIFF = 12e3;
 var cut = (s) => s && s.length > MAX_DIFF ? `${s.slice(0, MAX_DIFF)}
@@ -11228,6 +11368,14 @@ async function applySuggestionOp(ctx, a) {
     return { number: n, status: "refused", outcome: "refused", exitCode: 1, message: `Not applied: ${d.parsed.message}` };
   }
   if (d.status === "declined") return { number: n, status: "refused", outcome: "refused", exitCode: 1, message: `Not applied: #${n} was declined. Reopen it on GitHub first if it should go in after all.` };
+  if (d.status === "applied") {
+    const warnings2 = [];
+    if (ctx.canWriteRemote) {
+      const w = await syncSuggestionStateLabel(gh, n, d.issue.labels, "applied").catch((e) => `The status label on #${n} could not be updated (${e.message}).`);
+      if (w) warnings2.push(w);
+    }
+    return { number: n, status: "already-applied", outcome: "already-applied", exitCode: 0, message: `#${n} is already applied and closed: nothing to write.`, ...warnings2.length ? { warnings: warnings2 } : {} };
+  }
   const parsed = d.parsed;
   const dryRun = a.dryRun || a.mode === "dry-run";
   const mode = a.mode && a.mode !== "dry-run" ? a.mode : "branch";
@@ -11297,15 +11445,18 @@ async function linkSuggestionOp(ctx, a) {
   if (!d.parsed.ok) throw new Error(`#${n} cannot be linked: ${d.parsed.message}`);
   const warnings = [];
   let branch = a.branch;
+  let merged = false;
   if (a.pr) {
     const pr = await gh.getPullRequest(a.pr);
     branch ??= pr.headRef;
-    if (!closingIssueNumbers(pr.body).includes(n)) warnings.push(`#${a.pr} does not say "Closes #${n}": add it to the pull request description, so the suggestion closes when it merges.`);
+    merged = pr.state === "merged";
+    if (!merged && !closingIssueNumbers(pr.body).includes(n)) warnings.push(`#${a.pr} does not say "Closes #${n}": add it to the pull request description, so the suggestion closes when it merges.`);
   }
   const viewer = await viewerOf(ctx, gh);
-  const r = await linkSuggestionPrOnGitHub(gh, n, { pr: a.pr, branch, commit: a.commit, by: viewer ?? void 0, payloadSha: d.parsed.sha, forced: a.forced });
+  const r = await linkSuggestionPrOnGitHub(gh, n, { pr: a.pr, branch, commit: a.commit, by: viewer ?? void 0, payloadSha: d.parsed.sha, forced: a.forced, merged });
   warnings.push(...r.warnings);
-  return { number: n, status: "applying", said: SUGGESTION_STATUS_LABEL.applying, ...a.pr ? { pr: a.pr } : {}, ...branch ? { branch } : {}, ...warnings.length ? { warnings } : {}, next: "It closes when the pull request merges." };
+  const status = r.status;
+  return { number: n, status, said: SUGGESTION_STATUS_LABEL[status], ...a.pr ? { pr: a.pr } : {}, ...branch ? { branch } : {}, ...warnings.length ? { warnings } : {}, next: status === "applied" ? "Applied: nothing left to do." : "It closes when the pull request merges." };
 }
 async function createSuggestionOp(ctx, a) {
   const { config } = await ctx.config();
@@ -11935,7 +12086,7 @@ async function visualImpact(ctx, a, run2) {
   if (ctx.mode !== "local" || !ctx.root) throw new Error("Visual impact needs a local checkout (start Bridge with --root): it builds Storybook and the app at both refs.");
   if (!ctx.isGit) throw new Error(`${ctx.root} is not a git repository.`);
   const out = a.out ? resolve3(ctx.root, a.out) : join5(ctx.root, "visual-impact");
-  const runImpact = run2 ?? (await import("./src-UNWS2OVM.js")).runImpact;
+  const runImpact = run2 ?? (await import("./src-DRJFSLRV.js")).runImpact;
   const r = await runImpact({
     root: ctx.root,
     base: a.base ?? "main",
@@ -13003,7 +13154,7 @@ async function pushFigmaComponentOp(ctx, a) {
 }
 
 // src/server.ts
-var VERSION = true ? "0.8.2" : "dev";
+var VERSION = true ? "0.8.4" : "dev";
 var ok = (data) => ({ content: [{ type: "text", text: typeof data === "string" ? data : JSON.stringify(data, null, 2) }] });
 var fail2 = (e) => ({ content: [{ type: "text", text: `Error: ${e.message ?? String(e)}` }], isError: true });
 var run = (fn) => async (a) => {
@@ -13847,7 +13998,7 @@ function createServer(ctx) {
     "bridge_list_suggestions",
     {
       title: "List suggestions",
-      description: "Suggestions in the repo: GitHub issues labeled bridge-suggestion, each an exact change (tokens, docs, a component spec, a brand, a revert, settings) that the owners approve and a developer applies. Each row has the number, title, kind, tier, status (needs-review, changes-requested, approved, applying, applied, declined, outdated) and linked pull requests. Statuses here come from labels; bridge_get_suggestion counts the approvals.",
+      description: "Suggestions in the repo: GitHub issues labeled bridge-suggestion, each an exact change (tokens, docs, a component spec, a brand, a revert, settings) that the owners approve and a developer applies. Each row has the number, title, kind, tier, status (needs-review, changes-requested, approved, applying, applied, declined, outdated) and linked pull requests. Statuses here come from labels, except that an open one whose change no longer applies to main reads outdated; bridge_get_suggestion counts the approvals.",
       inputSchema: {
         status: z.enum(["needs-review", "changes-requested", "approved", "applying", "applied", "declined", "outdated", "all"]).optional().describe("Default all open ones."),
         state: z.enum(["open", "closed", "all"]).optional().describe("Issue state. Default: open, or closed for applied and declined."),