@bridge-ds/mcp 0.2.0 → 0.3.1

package/dist/{chunk-FJL6UTZG.js → chunk-X455XY4E.js}

@@ -43,18 +43,407 @@ function previewLinks(apps, ctx) {
   }
   return out;
 }
-function snapshotUrl(owner, repo, pkg, ref) {
-  return `https://pkg.pr.new/${owner}/${repo}/${pkg}@${ref}`;
+var PREVIEW_COMMENT_MARKER = "<!-- bridge-branch-preview -->";
+function installCommandFromPreviewComment(body) {
+  if (!body || !body.trimStart().startsWith(PREVIEW_COMMENT_MARKER)) return null;
+  const m = /```(?:sh|bash|shell)[^\n]*\n([\s\S]*?)```/.exec(body);
+  if (!m) return null;
+  const command = m[1].split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#")).join(" ").replace(/\s*\\\s+/g, " ").replace(/\s+/g, " ").trim();
+  return command || null;
 }
-function installCommand(urls, pm = "npm") {
-  const verb = pm === "npm" ? "npm i" : pm === "pnpm" ? "pnpm add" : "yarn add";
-  return `${verb} ${urls.join(" ")}`;
+function readPreviewComment(body) {
+  if (!body || !body.trimStart().startsWith(PREVIEW_COMMENT_MARKER)) return null;
+  const command = installCommandFromPreviewComment(body);
+  const sha7 = /Snapshot of `([0-9a-f]{7,40})`/.exec(body)?.[1]?.slice(0, 7) ?? null;
+  const source = !command ? "none" : command.includes("https://pkg.pr.new/") ? "pkg.pr.new" : /\/releases\/download\/preview-pr-\d+\//.test(command) ? "release" : "other";
+  return { command, sha7, source };
 }
-function tarballAssetName(pkg, sha) {
-  return `${pkg.replace(/^@/, "").replace(/\//g, "-")}-${sha.slice(0, 7)}.tgz`;
+function findPreviewComment(comments) {
+  return [...comments].reverse().find((c) => !!c.body && c.body.trimStart().startsWith(PREVIEW_COMMENT_MARKER));
 }
-function tarballUrl(owner, repo, pr, pkg, sha) {
-  return `https://github.com/${owner}/${repo}/releases/download/preview-pr-${pr}/${tarballAssetName(pkg, sha)}`;
+var httpsUrl = (raw) => {
+  if (!raw || typeof raw !== "string") return null;
+  try {
+    const u = new URL(/^https?:\/\//i.test(raw) ? raw : `https://${raw}`);
+    return u.protocol === "https:" || u.protocol === "http:" ? u.href : null;
+  } catch {
+    return null;
+  }
+};
+var decodeBase64 = (b64) => {
+  const bin = atob(b64.replace(/\s/g, ""));
+  const bytes = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+  return new TextDecoder("utf-8").decode(bytes);
+};
+var isVercelComment = (body) => !!body && /^\[vc\]: #[^:\s]*:[A-Za-z0-9+/=]+/m.test(body);
+function parseVercelComment(body) {
+  if (!body) return null;
+  const m = /^\[vc\]: #[^:\s]*:([A-Za-z0-9+/=]+)/m.exec(body);
+  if (!m) return null;
+  let data;
+  try {
+    data = JSON.parse(decodeBase64(m[1]));
+  } catch {
+    return null;
+  }
+  if (!data || !Array.isArray(data.projects)) return null;
+  return data.projects.filter((p) => p && typeof p.name === "string").map((p) => ({ name: p.name, previewUrl: httpsUrl(typeof p.previewUrl === "string" ? p.previewUrl : null), status: typeof p.nextCommitStatus === "string" ? p.nextCommitStatus : null }));
+}
+function findVercelComment(comments) {
+  return [...comments].reverse().find((c) => isVercelComment(c.body));
+}
+function templateHostPrefix(template) {
+  if (!template) return null;
+  const host = /^https?:\/\/([^/?#]+)/i.exec(template)?.[1];
+  if (!host) return null;
+  return host.split(".")[0].split("{")[0].toLowerCase();
+}
+function appForProject(project, apps) {
+  const name = project.trim().toLowerCase();
+  if (!name) return null;
+  const keys = Object.keys(PREVIEW_APP_LABELS);
+  const prefixes = keys.map((app) => [app, templateHostPrefix(apps[app])]);
+  const exact = prefixes.find(([, p]) => p === `${name}-git-` || p === name);
+  if (exact) return exact[0];
+  const loose = prefixes.filter(([, p]) => p !== null && p.startsWith(`${name}-`));
+  return loose.length === 1 ? loose[0][0] : null;
+}
+function projectOfLabel(label) {
+  const m = /^\s*(?:preview|vercel)\s*[\u2013\u2014-]\s*(.+?)\s*$/i.exec(label);
+  return m ? m[1] : null;
+}
+var STATE_OF = {
+  success: "ready",
+  inactive: "ready",
+  deployed: "ready",
+  ready: "ready",
+  ignored: "ready",
+  // Vercel skipped the build (nothing changed for this app): the branch alias serves the last one.
+  pending: "building",
+  queued: "building",
+  in_progress: "building",
+  building: "building",
+  initializing: "building",
+  failure: "failed",
+  error: "failed",
+  failed: "failed",
+  canceled: "failed"
+};
+var stateOf = (s) => STATE_OF[(s ?? "").toLowerCase()] ?? "unknown";
+var isInspectorUrl = (u) => /^https:\/\/(?:www\.)?vercel\.com\//i.test(u);
+function resolveBranchPreviews(apps, ctx, sources = {}) {
+  const seen = /* @__PURE__ */ new Map();
+  const at = (app) => seen.get(app) ?? (seen.set(app, {}), seen.get(app));
+  const offer = (app, url, urlSource, state, stateRank) => {
+    if (!app) return;
+    const s = at(app);
+    if (url && !s.url) Object.assign(s, { url, urlSource });
+    if (state !== "unknown" && (s.stateRank === void 0 || stateRank < s.stateRank)) Object.assign(s, { state, stateRank });
+  };
+  const contexts = /* @__PURE__ */ new Set();
+  for (const st of sources.statuses ?? []) {
+    if (contexts.has(st.context)) continue;
+    contexts.add(st.context);
+    const project = projectOfLabel(st.context);
+    if (!project) continue;
+    const url = httpsUrl(st.target_url);
+    offer(appForProject(project, apps), url && !isInspectorUrl(url) ? url : null, "status", stateOf(st.state), 0);
+  }
+  for (const d of sources.deployments ?? []) {
+    const project = projectOfLabel(d.environment);
+    const app = project ? appForProject(project, apps) : null;
+    if (!app) continue;
+    const url = httpsUrl(d.environmentUrl);
+    const s = at(app);
+    if (url && s.urlSource !== "deployment") Object.assign(s, { url, urlSource: "deployment" });
+    const state = stateOf(d.state);
+    if (state !== "unknown" && (s.stateRank === void 0 || 1 < s.stateRank)) Object.assign(s, { state, stateRank: 1 });
+  }
+  for (const p of parseVercelComment(findVercelComment(sources.comments ?? [])?.body) ?? []) offer(appForProject(p.name, apps), p.previewUrl, "vercel-comment", stateOf(p.status), 2);
+  const out = [];
+  for (const app of Object.keys(PREVIEW_APP_LABELS)) {
+    if (!apps[app]) continue;
+    const s = seen.get(app) ?? {};
+    const url = s.url ?? previewUrl(apps[app], ctx);
+    const source = s.url ? s.urlSource : url ? "template" : null;
+    out.push({ app, label: PREVIEW_APP_LABELS[app], url, state: s.state ?? "unknown", source });
+  }
+  return out;
+}
+var previewsSettled = (previews) => previews.every((p) => !!p.url && (p.state === "ready" || p.state === "failed"));
+
+// ../core/src/teams.ts
+var LOGIN = /^[A-Za-z0-9](?:[A-Za-z0-9]|-(?=[A-Za-z0-9])){0,38}$/;
+var SLUG = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
+function parseOwnerEntry(raw) {
+  if (typeof raw !== "string") return null;
+  const s = raw.trim().replace(/^@/, "");
+  const slash = s.indexOf("/");
+  if (slash < 0) return LOGIN.test(s) ? { kind: "person", login: s } : null;
+  const org = s.slice(0, slash);
+  const slug = s.slice(slash + 1);
+  return LOGIN.test(org) && SLUG.test(slug) ? { kind: "team", org, slug } : null;
+}
+var teamKey = (org, slug) => `@${org.toLowerCase()}/${slug.toLowerCase()}`;
+function ownerEntryProblems(raw) {
+  if (raw === void 0) return [];
+  const isObj2 = (x) => Boolean(x) && typeof x === "object" && !Array.isArray(x);
+  if (!isObj2(raw)) return ['"governance.owners" must be { "design": [people or teams], "tech": [people or teams] }'];
+  const out = [];
+  for (const [k, v] of Object.entries(raw)) {
+    if (k !== "design" && k !== "tech") {
+      out.push(`"governance.owners.${k}" is not an owner group (design, tech)`);
+      continue;
+    }
+    if (!Array.isArray(v)) {
+      out.push(`"governance.owners.${k}" must be a list of people or teams`);
+      continue;
+    }
+    v.forEach((x, i) => {
+      if (typeof x !== "string" || !parseOwnerEntry(x))
+        out.push(`"governance.owners.${k}[${i}]" (${JSON.stringify(x)}) is not a GitHub login or team. Write a person as "peterbono" or "@peterbono", a team as "@org/team-slug".`);
+    });
+  }
+  return out;
+}
+function teamUnreadableMessage(team, reason) {
+  const name = `@${team.org}/${team.slug}`;
+  switch (reason) {
+    case "personal-account":
+      return `${name} cannot be used: ${team.org} is a personal GitHub account, and teams only exist in organizations. List people instead, or move the repository to an organization.`;
+    case "missing-permission":
+      return `The members of ${name} cannot be read: the GitHub token needs read:org (classic token) or Members: Read on the ${team.org} organization (fine-grained token).`;
+    case "no-token":
+      return `The members of ${name} cannot be read without a working GitHub token. Connect GitHub with a token that has read:org.`;
+    case "not-found":
+      return `${name} was not found. Check the team slug on GitHub, or give the token read:org so it can see the team.`;
+    case "unreachable":
+      return `The members of ${name} cannot be read right now: GitHub did not answer. Try again in a moment.`;
+  }
+}
+function teamsIn(owners) {
+  const all = Array.isArray(owners) ? owners : [...owners.design ?? [], ...owners.tech ?? []];
+  const out = /* @__PURE__ */ new Map();
+  for (const raw of all) {
+    const e = parseOwnerEntry(raw);
+    if (e?.kind === "team") out.set(teamKey(e.org, e.slug), { key: teamKey(e.org, e.slug), org: e.org, slug: e.slug });
+  }
+  return [...out.values()];
+}
+var norm = (x) => x.trim().toLowerCase().replace(/^@/, "");
+function expandEntries(entries, teams) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (x) => {
+    const k = norm(x);
+    if (k && !seen.has(k)) {
+      seen.add(k);
+      out.push(x.replace(/^@(?=[^/]+$)/, ""));
+    }
+  };
+  for (const raw of entries) {
+    const e = parseOwnerEntry(raw);
+    if (!e) continue;
+    if (e.kind === "person") add(e.login);
+    else {
+      const state = teams?.[teamKey(e.org, e.slug)];
+      if (state?.status === "ok") state.members.forEach(add);
+      else add(teamKey(e.org, e.slug));
+    }
+  }
+  return out;
+}
+function expandOwners(owners, teams) {
+  return { design: expandEntries(owners.design, teams), tech: expandEntries(owners.tech, teams) };
+}
+var people = (n) => `${n} ${n === 1 ? "person" : "people"}`;
+function entryLabel(raw, teams) {
+  const e = parseOwnerEntry(raw);
+  if (!e) return raw;
+  if (e.kind === "person") return `@${e.login}`;
+  const state = teams?.[teamKey(e.org, e.slug)];
+  const name = `@${e.org}/${e.slug}`;
+  return state?.status === "ok" ? `${name} (${people(state.members.length)})` : name;
+}
+function unreadableTeams(teams) {
+  return Object.values(teams ?? {}).filter((t) => t.status === "unreadable");
+}
+var TeamDirectory = class {
+  constructor(reader, opts = {}) {
+    this.reader = reader;
+    this.ttl = opts.ttlMs ?? 5 * 6e4;
+    this.now = opts.now ?? Date.now;
+  }
+  reader;
+  teams = /* @__PURE__ */ new Map();
+  accounts = /* @__PURE__ */ new Map();
+  memberships = /* @__PURE__ */ new Map();
+  ttl;
+  now;
+  accountType(org) {
+    const k = org.toLowerCase();
+    let p = this.accounts.get(k);
+    if (!p) {
+      p = this.reader.getAccountType(org).catch(() => null);
+      this.accounts.set(k, p);
+    }
+    return p;
+  }
+  /** The reason a read of `org` failed, as a state. A 404 on a personal account says so; a 403 is a missing permission. */
+  async failure(ref, err) {
+    const e = err ?? {};
+    let reason;
+    if (!this.reader.hasToken) reason = await this.accountType(ref.org) === "User" ? "personal-account" : "no-token";
+    else if (e.status === 401) reason = "no-token";
+    else if (e.status === 403 || e.auth === "missing-permission") reason = "missing-permission";
+    else if (e.status === 404) reason = await this.accountType(ref.org) === "User" ? "personal-account" : "not-found";
+    else reason = "unreachable";
+    return { ...ref, status: "unreadable", reason, message: teamUnreadableMessage(ref, reason) };
+  }
+  /** Members of one team, or why they cannot be read. Cached. */
+  team(org, slug) {
+    const ref = { key: teamKey(org, slug), org, slug };
+    const hit = this.teams.get(ref.key);
+    if (hit && this.now() - hit.at < this.ttl) return hit.value;
+    const value = (async () => {
+      if (!this.reader.hasToken) return this.failure(ref, void 0);
+      try {
+        const members = await this.reader.listTeamMembers(org, slug);
+        return { ...ref, status: "ok", members };
+      } catch (err) {
+        return this.failure(ref, err);
+      }
+    })();
+    this.teams.set(ref.key, { at: this.now(), value });
+    void value.then((s) => {
+      if (s.status === "unreadable" && s.reason === "unreachable") this.teams.delete(ref.key);
+    });
+    return value;
+  }
+  /** Every team named in the owner lists, read in parallel. Empty object when no team is named (no request). */
+  async resolve(owners) {
+    const refs = teamsIn(owners);
+    const states = await Promise.all(refs.map((r) => this.team(r.org, r.slug)));
+    return Object.fromEntries(states.map((s) => [s.key, s]));
+  }
+  /**
+   * Whether `login` is an active member of one team: from the cached member list when there is one, else one
+   * membership read (GET /orgs/{org}/teams/{slug}/memberships/{user}). An unreadable team returns its state.
+   */
+  async isMember(org, slug, login) {
+    const ref = { key: teamKey(org, slug), org, slug };
+    const cached = this.teams.get(ref.key);
+    if (cached && this.now() - cached.at < this.ttl) {
+      const s = await cached.value;
+      if (s.status === "ok") return s.members.some((m) => norm(m) === norm(login));
+    }
+    const k = `${ref.key}#${norm(login)}`;
+    const hit = this.memberships.get(k);
+    if (hit && this.now() - hit.at < this.ttl) return hit.value;
+    const value = (async () => {
+      if (!this.reader.hasToken) return this.failure(ref, void 0);
+      try {
+        return await this.reader.getTeamMembership(org, slug, login) === "active";
+      } catch (err) {
+        return this.failure(ref, err);
+      }
+    })();
+    this.memberships.set(k, { at: this.now(), value });
+    return value;
+  }
+  /**
+   * Whether `login` holds a right given to `entries` (people and teams): a person entry matches directly, a team
+   * through its membership. Teams are only read when no person entry matches.
+   */
+  async memberOfAny(entries, login) {
+    const unreadable = [];
+    const parsed = entries.map(parseOwnerEntry).filter((e) => Boolean(e));
+    if (parsed.some((e) => e.kind === "person" && norm(e.login) === norm(login))) return { member: true, unreadable };
+    for (const e of parsed) {
+      if (e.kind !== "team") continue;
+      const r = await this.isMember(e.org, e.slug, login);
+      if (r === true) return { member: true, unreadable };
+      if (typeof r === "object" && r.status === "unreadable") unreadable.push(r);
+    }
+    return { member: false, unreadable };
+  }
+  /** The organization's teams for a picker, or why they cannot be listed (a personal account has none). */
+  async orgTeams(org) {
+    if (await this.accountType(org) === "User") return { status: "unreadable", reason: "personal-account" };
+    if (!this.reader.hasToken) return { status: "unreadable", reason: "no-token" };
+    try {
+      return { status: "ok", teams: await this.reader.listOrgTeams(org) };
+    } catch (err) {
+      const s = await this.failure({ key: teamKey(org, "*"), org, slug: "*" }, err);
+      return { status: "unreadable", reason: s.status === "unreadable" ? s.reason : "unreachable" };
+    }
+  }
+  /** Drops every cached read (after the token changes). */
+  clear() {
+    this.teams.clear();
+    this.accounts.clear();
+    this.memberships.clear();
+  }
+};
+
+// ../core/src/rights.ts
+var OWNER_GROUPS = ["design", "tech"];
+var RIGHTS = ["approveDesign", "approveTech", "ship"];
+var DEFAULT_RIGHTS = { approveDesign: ["design"], approveTech: ["tech"], ship: ["tech"] };
+var uniq = (xs) => [...new Set(xs)];
+function normalizeRights(input) {
+  const pick = (r) => {
+    const v = input?.[r];
+    if (!Array.isArray(v)) return [...DEFAULT_RIGHTS[r]];
+    return OWNER_GROUPS.filter((g) => v.includes(g));
+  };
+  return { approveDesign: pick("approveDesign"), approveTech: pick("approveTech"), ship: pick("ship") };
+}
+function rightsProblems(raw) {
+  if (raw === void 0) return [];
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return ['"governance.rights" must be { "approveDesign": [groups], "approveTech": [groups], "ship": [groups] }'];
+  const out = [];
+  for (const [k, v] of Object.entries(raw)) {
+    if (!RIGHTS.includes(k)) out.push(`"governance.rights.${k}" is not a right (${RIGHTS.join(", ")})`);
+    else if (!Array.isArray(v) || v.length === 0 || !v.every((g) => OWNER_GROUPS.includes(g)))
+      out.push(`"governance.rights.${k}" must list one or more of "design", "tech"`);
+  }
+  return out;
+}
+function holdersOf(right, owners, rights) {
+  const groups = (rights ?? DEFAULT_RIGHTS)[right];
+  return uniq(groups.flatMap((g) => owners[g] ?? []));
+}
+function approverEntries(owners, rights) {
+  if (!rights) return { design: [...owners.design], tech: [...owners.tech] };
+  return { design: holdersOf("approveDesign", owners, rights), tech: holdersOf("approveTech", owners, rights) };
+}
+function shipPolicy(owners, rights, teams) {
+  if (!rights) return null;
+  const entries = holdersOf("ship", owners, rights);
+  if (!entries.length) return null;
+  const logins = expandEntries(entries, teams);
+  return { logins, groups: [...rights.ship], entries, ...teams ? { teams } : {} };
+}
+function groupsPhrase(groups) {
+  const g = OWNER_GROUPS.filter((x) => groups.includes(x));
+  if (g.length === 1) return `the ${g[0]} owner`;
+  return `a ${g.join(" or ")} owner`;
+}
+function whoCanShipSentence(policy) {
+  const names = (policy.entries ?? policy.logins).map((l) => entryLabel(l, policy.teams)).join(", ");
+  return `Only ${groupsPhrase(policy.groups)} can ship this${names ? ` (${names})` : ""}.`;
+}
+function visualImpactProblems(raw) {
+  if (raw === void 0) return [];
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return ['"visualImpact" must be { "mode": "auto" | "on-demand" }'];
+  const out = [];
+  for (const [k, v] of Object.entries(raw)) {
+    if (k !== "mode") out.push(`"visualImpact.${k}" is not a setting (mode)`);
+    else if (v !== "auto" && v !== "on-demand") out.push('"visualImpact.mode" must be "auto" or "on-demand"');
+  }
+  return out;
 }
 
 // ../core/src/config.ts
@@ -194,9 +583,11 @@ function defineConfig(input) {
           requireReason: g.override.requireReason ?? DEFAULT_OVERRIDE.requireReason,
           minReasonLength: g.override.minReasonLength ?? DEFAULT_OVERRIDE.minReasonLength
         }
-      } : {}
+      } : {},
+      ...g.rights ? { rights: normalizeRights(g.rights) } : {}
     },
     ...input.audit ? { audit: { ...input.audit } } : {},
+    ...input.visualImpact ? { visualImpact: { mode: input.visualImpact.mode === "on-demand" ? "on-demand" : "auto" } } : {},
     ...input.integrations ? { integrations: { ...input.integrations } } : {},
     ...input.previews ? {
       previews: {
@@ -303,9 +694,7 @@ function loadConfig(source) {
     else {
       for (const k of ["protectedBranches", "labels", "guardrails"]) if (gov[k] !== void 0 && !(Array.isArray(gov[k]) && gov[k].every((x) => typeof x === "string"))) problems.push(`"governance.${k}" must be a list of strings`);
       if (gov.branchPrefix !== void 0 && !isStr(gov.branchPrefix)) problems.push('"governance.branchPrefix" must be a non-empty string');
-      const o = gov.owners;
-      if (o !== void 0 && (!isObj(o) || ["design", "tech"].some((k) => o[k] !== void 0 && !(Array.isArray(o[k]) && o[k].every((x) => typeof x === "string")))))
-        problems.push('"governance.owners" must be { "design": [logins], "tech": [logins] }');
+      problems.push(...ownerEntryProblems(gov.owners));
       const ov = gov.override;
       if (ov !== void 0) {
         if (!isObj(ov)) problems.push('"governance.override" must be an object');
@@ -315,8 +704,10 @@ function loadConfig(source) {
           if (ov.minReasonLength !== void 0 && !(Number.isInteger(ov.minReasonLength) && ov.minReasonLength >= 0)) problems.push('"governance.override.minReasonLength" must be a whole number, 0 or more');
         }
       }
+      problems.push(...rightsProblems(gov.rights));
     }
   }
+  problems.push(...visualImpactProblems(d.visualImpact));
   const audit = d.audit;
   if (audit !== void 0) {
     if (!isObj(audit)) problems.push('"audit" must be an object');
@@ -362,7 +753,8 @@ function toConfigJson(config, schema = "./packages/core/bridge.config.schema.jso
     cssVar: config.cssVar,
     governance: config.governance,
     ...config.audit ? { audit: config.audit } : {},
-    ...config.previews ? { previews: config.previews } : {}
+    ...config.previews ? { previews: config.previews } : {},
+    ...config.visualImpact ? { visualImpact: config.visualImpact } : {}
   };
 }
 
@@ -1270,9 +1662,18 @@ async function identityEnv(root) {
 export {
   __export,
   previewLinks,
-  snapshotUrl,
-  installCommand,
-  tarballUrl,
+  readPreviewComment,
+  findPreviewComment,
+  resolveBranchPreviews,
+  previewsSettled,
+  expandOwners,
+  entryLabel,
+  unreadableTeams,
+  TeamDirectory,
+  DEFAULT_RIGHTS,
+  approverEntries,
+  shipPolicy,
+  whoCanShipSentence,
   CONFIG_FILE,
   loadConfig,
   tokensPath,

package/dist/drafts.d.ts

@@ -1,4 +1,4 @@
-import { type PendingDrafts } from '@bridge-ds/core';
+import { type DraftResultInput, type PendingDrafts } from '@bridge-ds/core';
 import type { BridgeContext } from './context.js';
 /** Images larger than this are linked, not inlined (bytes of PNG). */
 export declare const IMAGE_INLINE_MAX = 750000;
@@ -8,6 +8,8 @@ export interface InlineImage {
     sessionId: string;
     itemId: string;
     label: 'before' | 'after';
+    /** The change line this image shows (push items with several components). */
+    line?: string | undefined;
     base64: string;
 }
 export interface PendingDraftsAnswer {
@@ -32,11 +34,7 @@ export declare function pendingDrafts(ctx: BridgeContext, a: {
 /** Writes Claude's texts into a session (sanitized, status "drafted" once every item has one), retrying on 409. */
 export declare function writeDrafts(ctx: BridgeContext, a: {
     sessionId: string;
-    results: {
-        id: string;
-        title: string;
-        summary: string;
-    }[];
+    results: DraftResultInput[];
 }): Promise<{
     next: string;
     waiting?: string[] | undefined;

package/dist/explorations.d.ts

@@ -1,4 +1,4 @@
-import { explorationRules } from '@bridge-ds/core';
+import { explorationRules, type ExplorationSource, type ExplorationTryIt } from '@bridge-ds/core';
 import { BridgeContext } from './context.js';
 /** `explore/<slug>` from a branch, a slug or a name; throws with how to fix it when it cannot be one. */
 export declare function toExplorationBranch(ref: string): string;
@@ -8,6 +8,9 @@ export interface StartExplorationInput {
     useCase?: string | undefined;
     experimental?: string[] | undefined;
     author?: string | undefined;
+    /** Where it is started from (the MCP tool says mcp, the CLI says cli), and the AI agent behind it when known. */
+    source?: ExplorationSource | undefined;
+    agent?: string | undefined;
     dryRun?: boolean | undefined;
 }
 /**
@@ -31,7 +34,11 @@ export declare function startExploration(ctx: BridgeContext, a: StartExploration
     pr: number;
     url: string;
     commit: string;
-    install: import("@bridge-ds/core").ExplorationInstall;
+    install: {
+        state: ExplorationTryIt["state"];
+        command: string | null;
+        note: string;
+    };
     previews: {
         app: string;
         label: string;
@@ -64,6 +71,15 @@ export declare function startExploration(ctx: BridgeContext, a: StartExploration
     prBody: string;
     status: "branch-created";
 }>;
+/**
+ * The install command of an exploration as tools show it: the one the preview workflow published (its sticky comment
+ * on the pull request), or why there is none yet. Never a guessed pkg.pr.new URL.
+ */
+export declare function installOf(t: ExplorationTryIt): {
+    state: ExplorationTryIt['state'];
+    command: string | null;
+    note: string;
+};
 /** bridge_list_explorations / `bridge explore list`. */
 export declare function listExplorations(ctx: BridgeContext, a?: {
     state?: 'open' | 'closed' | 'all';
@@ -75,7 +91,8 @@ export declare function listExplorations(ctx: BridgeContext, a?: {
     running: number;
     total: number;
     summary: string;
-    explorations: {
+    explorations: ({
+        install: null;
         requests: {
             number: number;
             title: string;
@@ -92,14 +109,79 @@ export declare function listExplorations(ctx: BridgeContext, a?: {
         status: import("@bridge-ds/core").ExplorationStatus;
         draft: boolean;
         author: string;
+        source?: ExplorationSource | undefined;
+        agent?: string | undefined;
         updatedAt: string;
+        headSha: string;
         previews: {
             app: string;
             label: string;
             url: string;
         }[];
-        install: import("@bridge-ds/core").ExplorationInstall;
-    }[];
+    } | {
+        install: {
+            state: ExplorationTryIt["state"];
+            command: string | null;
+            note: string;
+        };
+        requests: {
+            number: number;
+            title: string;
+            url: string;
+            state: string;
+        }[];
+        number: number;
+        url: string;
+        branch: string;
+        slug: string;
+        name: string;
+        purpose: string;
+        useCase?: string | undefined;
+        status: import("@bridge-ds/core").ExplorationStatus;
+        draft: boolean;
+        author: string;
+        source?: ExplorationSource | undefined;
+        agent?: string | undefined;
+        updatedAt: string;
+        headSha: string;
+        previews: {
+            app: string;
+            label: string;
+            url: string;
+        }[];
+    } | {
+        previews: {
+            app: keyof import("@bridge-ds/core").PreviewApps;
+            label: string;
+            url: string | null;
+            state: import("@bridge-ds/core").PreviewState;
+        }[];
+        install: {
+            state: ExplorationTryIt["state"];
+            command: string | null;
+            note: string;
+        };
+        requests: {
+            number: number;
+            title: string;
+            url: string;
+            state: string;
+        }[];
+        number: number;
+        url: string;
+        branch: string;
+        slug: string;
+        name: string;
+        purpose: string;
+        useCase?: string | undefined;
+        status: import("@bridge-ds/core").ExplorationStatus;
+        draft: boolean;
+        author: string;
+        source?: ExplorationSource | undefined;
+        agent?: string | undefined;
+        updatedAt: string;
+        headSha: string;
+    })[];
 }>;
 /** `bridge explore promote`: ready for review, tier labels, exploration label and note removed, linked requests closed on merge. */
 export declare function promoteExploration(ctx: BridgeContext, a: {

package/dist/index.js

@@ -3,8 +3,8 @@ import {
   VERSION,
   optionsFromArgv,
   serveStdio
-} from "./chunk-6JO2AG6X.js";
-import "./chunk-FJL6UTZG.js";
+} from "./chunk-I3TL76GK.js";
+import "./chunk-X455XY4E.js";
 
 // src/index.ts
 var argv = process.argv.slice(2);

package/dist/lib.d.ts

@@ -11,6 +11,7 @@ export * as brand from './brand.js';
 export * as requests from './requests.js';
 export * as explorations from './explorations.js';
 export * as drafts from './drafts.js';
+export { DOCS_DRAFT_MODEL, anthropicReplyText, anthropicRequest, formatDocsJson, mergeDocsDraft, missingProse, parseDocsReply } from '@bridge-ds/core';
 export interface ServeOptions extends ContextOptions {
 }
 /** Starts the stdio MCP server. Logs go to stderr: stdout belongs to the protocol. */