@bridge-ds/mcp 0.10.0 → 0.11.1

package/dist/{chunk-BZEPCY42.js → chunk-HNGVASTJ.js}

@@ -119,7 +119,7 @@ var STATE_OF = {
   deployed: "ready",
   ready: "ready",
   ignored: "ready",
-  // Vercel skipped the build (nothing changed for this app): the branch alias serves the last one.
+  // Vercel skipped the build: nothing to wait for. BranchPreview.skipped says the branch has no build of its own.
   pending: "building",
   queued: "building",
   in_progress: "building",
@@ -131,13 +131,15 @@ var STATE_OF = {
   canceled: "failed"
 };
 var stateOf = (s) => STATE_OF[(s ?? "").toLowerCase()] ?? "unknown";
+var IGNORED_BUILD = /ignored build step/i;
 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) => {
+  const offer = (app, url, urlSource, state, stateRank, skipped) => {
     if (!app) return;
     const s = at(app);
+    if (skipped !== void 0 && (s.skipRank === void 0 || stateRank < s.skipRank)) Object.assign(s, { skipped, skipRank: stateRank });
     if (url && !s.url) Object.assign(s, { url, urlSource });
     if (state !== "unknown" && (s.stateRank === void 0 || stateRank < s.stateRank)) Object.assign(s, { state, stateRank });
   };
@@ -148,7 +150,7 @@ function resolveBranchPreviews(apps, ctx, sources = {}) {
     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);
+    offer(appForProject(project, apps), url && !isInspectorUrl(url) ? url : null, "status", stateOf(st.state), 0, IGNORED_BUILD.test(st.description ?? ""));
   }
   for (const d of sources.deployments ?? []) {
     const project = projectOfLabel(d.environment);
@@ -160,17 +162,18 @@ function resolveBranchPreviews(apps, ctx, sources = {}) {
     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);
+  for (const p of parseVercelComment(findVercelComment(sources.comments ?? [])?.body) ?? []) offer(appForProject(p.name, apps), p.previewUrl, "vercel-comment", stateOf(p.status), 2, p.status ? p.status.toUpperCase() === "IGNORED" : void 0);
   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 });
+    out.push({ app, label: PREVIEW_APP_LABELS[app], url, state: s.state ?? "unknown", source, ...s.skipped ? { skipped: true } : {} });
   }
   return out;
 }
+var previewLinksOf = (previews) => previews.filter((p) => !!p.url && !p.skipped).map((p) => ({ app: p.app, label: p.label, url: p.url }));
 var previewsSettled = (previews) => previews.every((p) => p.state === "failed" || !!p.url && p.state === "ready");
 
 // ../core/src/teams.ts
@@ -533,9 +536,30 @@ function productForPlace(products, place) {
   }
   return { product: defaultProduct(products), how: "default" };
 }
+function productRepoOf(p, designSystemRepo) {
+  const repo = p?.repo?.trim();
+  if (!repo || !REPO.test(repo)) return null;
+  return repo.toLowerCase() === (designSystemRepo ?? "").trim().toLowerCase() ? null : repo;
+}
+function productRepos(products, designSystemRepo) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const p of products) {
+    const repo = productRepoOf(p, designSystemRepo);
+    if (!repo || seen.has(repo.toLowerCase())) continue;
+    seen.add(repo.toLowerCase());
+    out.push({ product: p, repo });
+  }
+  return out;
+}
+function productOfRepo(products, repo, designSystemRepo) {
+  const r = (repo ?? "").trim().toLowerCase();
+  if (!r) return void 0;
+  return productRepos(products, designSystemRepo).find((x) => x.repo.toLowerCase() === r)?.product;
+}
 var KEY = /^[a-z0-9][a-z0-9-]*$/;
 var REPO = /^[\w.-]+\/[\w.-]+$/;
-var FIELDS = ["key", "name", "repo", "path", "preview", "framework", "default"];
+var FIELDS = ["key", "name", "repo", "path", "preview", "production", "framework", "default"];
 function productProblems(raw) {
   if (raw === void 0) return [];
   if (!Array.isArray(raw)) return ['"products" must be a list of { "key", "name" } objects'];
@@ -561,6 +585,7 @@ function productProblems(raw) {
       if (bad) problems.push(`${at}.path" must be a folder relative to the repository root, without a leading "/" or "..", such as "apps/admin"`);
     }
     if (o.preview !== void 0 && (typeof o.preview !== "string" || !/^https?:\/\//.test(o.preview))) problems.push(`${at}.preview" must be an http(s) URL template, such as "https://app-git-{branch}.vercel.app"`);
+    if (o.production !== void 0 && (typeof o.production !== "string" || !/^https?:\/\/[^{}\s]+$/.test(o.production))) problems.push(`${at}.production" must be the product's production URL, without placeholders, such as "https://shop.example.com"`);
     if (o.framework !== void 0 && (typeof o.framework !== "string" || !o.framework.trim())) problems.push(`${at}.framework" must be a name such as "react", "vue" or "other"`);
     if (o.default !== void 0 && typeof o.default !== "boolean") problems.push(`${at}.default" must be true or false`);
     if (o.default === true) defaults++;
@@ -1832,6 +1857,23 @@ function hashSpec(spec) {
   return specHash(JSON.stringify(rest));
 }
 var variantKeyOf = (props) => Object.keys(props).sort().map((k) => `${k}=${props[k]}`).join(", ") || "Default";
+function matchVariant(spec, props) {
+  if (!spec) return void 0;
+  const key = variantKeyOf(props);
+  const exact = spec.variants.find((v) => variantKeyOf(v.props) === key);
+  if (exact) return exact;
+  const asked = Object.entries(props);
+  const fits = spec.variants.filter((v) => Object.keys(v.props).length > asked.length && asked.every(([k, val]) => v.props[k] === val));
+  if (fits.length <= 1) return fits[0];
+  const atDefault = (name, value) => {
+    const axis = spec.axes?.find((a) => a.name === name);
+    if (axis) return value === axis.default;
+    const v = value.toLowerCase();
+    return v === "false" || v === "default";
+  };
+  const best = fits.filter((v) => Object.entries(v.props).every(([k, val]) => k in props || atDefault(k, val)));
+  return best.length === 1 ? best[0] : void 0;
+}
 function parseComponentSpecs(text) {
   let data;
   try {
@@ -2124,6 +2166,7 @@ export {
   readPreviewComment,
   findPreviewComment,
   resolveBranchPreviews,
+  previewLinksOf,
   previewsSettled,
   expandOwners,
   entryLabel,
@@ -2145,6 +2188,9 @@ export {
   findProduct,
   productOfBranch,
   productForPlace,
+  productRepoOf,
+  productRepos,
+  productOfRepo,
   CONFIG_FILE,
   DEFAULT_OVERRIDE,
   DEFAULT_TOKEN_PATHS,
@@ -2190,6 +2236,7 @@ export {
   coverageSummary,
   hashSpec,
   variantKeyOf,
+  matchVariant,
   parseComponentSpecs,
   figmaCell,
   FIGMA_REFERENCES_BRANCH,

package/dist/context.d.ts

@@ -23,6 +23,13 @@ export interface ContextOptions {
     surface?: 'mcp' | 'cli';
     /** How a person adds a token where Bridge runs, for the rate-limit message. Default: the MCP server's environment. */
     tokenHint?: string;
+    /**
+     * Remote mode run inside a connected product repository (`.bridge/product.json`, product-link.ts): that checkout,
+     * which continuing one of its explorations switches to the branch when safe.
+     */
+    workTree?: string;
+    /** The product key of that repository: new work and a bare reference (#12) default to it. */
+    product?: string;
 }
 /** Whether a request only reads: GET and HEAD, and GraphQL queries (POST /graphql without a mutation). */
 export declare function isReadRequest(url: string, init?: {
@@ -52,6 +59,18 @@ export declare class BridgeContext {
      * branch are refused, new branches need the agent prefix. Local mode uses config.repo or the origin remote.
      */
     github(): Promise<GitHubClient | null>;
+    /**
+     * A client for another repository (a product's own one) with the same token, fetch and hosts. Its default branch
+     * and the protected ones are refused, new branches need `branchPrefix`.
+     */
+    githubFor(repo: string, rules: {
+        protectedBranches: string[];
+        branchPrefix: string;
+    }): GitHubClient;
+    /** The local checkout Bridge may switch branches in: the repo root in local mode, the connected product checkout in remote mode. */
+    get checkout(): string | undefined;
+    /** The product of the connected product repository Bridge runs in (`.bridge/product.json`), if any. */
+    get product(): string | undefined;
     get canWriteRemote(): boolean;
     /** Who reads the messages: 'mcp' (tool names and arguments, the default) or 'cli' (commands and flags). */
     get surface(): 'mcp' | 'cli';

package/dist/explorations.d.ts

@@ -9,7 +9,8 @@ export declare const settingsOf: (config: BridgeConfig) => {
 export declare function toExplorationBranch(ref: string): string;
 export interface StartExplorationInput {
     name: string;
-    purpose: string;
+    /** What the designer wants to learn. Optional: nobody is asked for a brief; Claude passes their first sentence when it has one. */
+    purpose?: string | undefined;
     useCase?: string | undefined;
     experimental?: string[] | undefined;
     author?: string | undefined;
@@ -18,16 +19,61 @@ export interface StartExplorationInput {
     agent?: string | undefined;
     /** The product it is tried in (key or name, bridge.config.json "products"). Default: the product of the current folder or repo. */
     product?: string | undefined;
+    /**
+     * Where the branch is created. `product` (the default): in the product's own repository when the team connected one
+     * (bridge.config.json products[].repo), else in the design system repository. `library`: always in the design system
+     * repository, the fallback when the person chooses it because Bridge cannot reach the product repository.
+     */
+    where?: 'product' | 'library' | undefined;
     dryRun?: boolean | undefined;
 }
+/** What Claude says when Bridge cannot reach a product's own repository: the admin action first, the fallback on request. */
+export declare function productRepoBlocked(ctx: BridgeContext, product: string, repo: string, reason: 'not-connected' | 'read-only' | 'no-token'): string;
 /**
  * bridge_start_exploration / `bridge explore start`. With a GitHub token: the branch on GitHub from the default branch
  * and a draft pull request labeled exploration. Without one, in a local git repo: a local branch with the note,
  * nothing pushed, and the commands to push it and open the draft pull request.
  */
 export declare function startExploration(ctx: BridgeContext, a: StartExplorationInput): Promise<{
+    blocked?: string | undefined;
     branch: string;
     product: string;
+    repo: string;
+    inProductRepo: boolean;
+    slug: string;
+    base: string;
+    title: string;
+    label: string;
+    note: {
+        path: string;
+        content: string;
+    };
+    prBody: string;
+    status: "dry-run";
+} | {
+    pr: number;
+    url: string;
+    commit: string;
+    next: string;
+    branch: string;
+    product: string;
+    repo: string;
+    inProductRepo: boolean;
+    slug: string;
+    base: string;
+    title: string;
+    label: string;
+    note: {
+        path: string;
+        content: string;
+    };
+    prBody: string;
+    status: "started";
+} | {
+    branch: string;
+    product: string;
+    repo: string | null;
+    inProductRepo: boolean;
     slug: string;
     base: string;
     title: string;
@@ -55,6 +101,8 @@ export declare function startExploration(ctx: BridgeContext, a: StartExploration
     next: string;
     branch: string;
     product: string;
+    repo: string | null;
+    inProductRepo: boolean;
     slug: string;
     base: string;
     title: string;
@@ -70,6 +118,8 @@ export declare function startExploration(ctx: BridgeContext, a: StartExploration
     next: string;
     branch: string;
     product: string;
+    repo: string | null;
+    inProductRepo: boolean;
     slug: string;
     base: string;
     title: string;
@@ -93,6 +143,8 @@ export declare function installOf(t: ExplorationTryIt): {
 /** bridge_list_explorations / `bridge explore list`. */
 export declare function listExplorations(ctx: BridgeContext, a?: {
     state?: 'open' | 'closed' | 'all';
+    archived?: boolean | undefined;
+    mine?: boolean | undefined;
 }): Promise<{
     localBranches?: string[] | undefined;
     localHint?: string | undefined;
@@ -109,6 +161,7 @@ export declare function listExplorations(ctx: BridgeContext, a?: {
             url: string;
             state: string;
         }[];
+        ref: string;
         number: number;
         url: string;
         branch: string;
@@ -117,6 +170,7 @@ export declare function listExplorations(ctx: BridgeContext, a?: {
         purpose: string;
         useCase?: string | undefined;
         status: import("@bridge-ds/core").ExplorationStatus;
+        archived: boolean;
         draft: boolean;
         author: string;
         source?: ExplorationSource | undefined;
@@ -128,6 +182,8 @@ export declare function listExplorations(ctx: BridgeContext, a?: {
             label: string;
             url: string;
         }[];
+        repo?: string | undefined;
+        product?: string | undefined;
     } | {
         install: {
             state: ExplorationTryIt["state"];
@@ -140,6 +196,7 @@ export declare function listExplorations(ctx: BridgeContext, a?: {
             url: string;
             state: string;
         }[];
+        ref: string;
         number: number;
         url: string;
         branch: string;
@@ -148,6 +205,7 @@ export declare function listExplorations(ctx: BridgeContext, a?: {
         purpose: string;
         useCase?: string | undefined;
         status: import("@bridge-ds/core").ExplorationStatus;
+        archived: boolean;
         draft: boolean;
         author: string;
         source?: ExplorationSource | undefined;
@@ -159,6 +217,8 @@ export declare function listExplorations(ctx: BridgeContext, a?: {
             label: string;
             url: string;
         }[];
+        repo?: string | undefined;
+        product?: string | undefined;
     } | {
         previews: {
             app: keyof import("@bridge-ds/core").PreviewApps;
@@ -177,6 +237,7 @@ export declare function listExplorations(ctx: BridgeContext, a?: {
             url: string;
             state: string;
         }[];
+        ref: string;
         number: number;
         url: string;
         branch: string;
@@ -185,37 +246,137 @@ export declare function listExplorations(ctx: BridgeContext, a?: {
         purpose: string;
         useCase?: string | undefined;
         status: import("@bridge-ds/core").ExplorationStatus;
+        archived: boolean;
         draft: boolean;
         author: string;
         source?: ExplorationSource | undefined;
         agent?: string | undefined;
         updatedAt: string;
         headSha: string;
+        repo?: string | undefined;
+        product?: string | undefined;
     })[];
 }>;
-/** `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: {
+/**
+ * bridge_promote_exploration (kept name) / `bridge explore done` (`promote` is an alias): "Done exploring". The pieces
+ * named in `pieces` (ids from bridge_missing_pieces) go to the DS lead as requests with the preview link; the
+ * exploration label and note go, `ready-for-devs` comes, and developers take the branch from there. Nothing is closed,
+ * merged or marked ready for review, so the preview link stays alive. Without `pieces`, the result lists the pieces
+ * still unsent so the person can pick.
+ */
+export declare function doneExploring(ctx: BridgeContext, a: {
     ref: string;
+    pieces?: string[] | undefined;
     dryRun?: boolean | undefined;
+    source?: ExplorationSource | undefined;
+    agent?: string | undefined;
 }): Promise<{
-    closes: number[];
-    number: number;
+    notProposed: {
+        id: string;
+        title: string;
+        summary: string;
+    }[];
+    checked: boolean;
+    forDevelopers: {
+        take: [string, string];
+        note: string;
+    };
+    warnings: string[];
+    next: string;
+    unknownPieces?: string[] | undefined;
     url: string;
     branch: string;
-    warnings: string[];
-    tier: import("@bridge-ds/core").RiskTier;
-    reasons: string[];
-    removeLabels: string[];
-    addLabels: string[];
+    exploration: import("@bridge-ds/core").ExplorationStatus;
+    labels: {
+        add: string[];
+        remove: string[];
+    } | null;
     removeFiles: string[];
-    body: string;
-    title: string;
-    markReady: true;
-    status: "promoted" | "dry-run";
+    requests: {
+        piece: string;
+        title: string;
+        number: number;
+        url: string;
+    }[];
+    alreadySent: {
+        piece: string;
+        number: number;
+    }[];
+    repo?: string | undefined;
+    product?: string | undefined;
+    requestsIn?: string | undefined;
+    status: "dry-run" | "done-exploring" | "already-done";
+    number: number;
+    ref: string;
+}>;
+/**
+ * bridge_continue_exploration / "Continue Bridge exploration #12" (or shop#12): resolves the exploration, switches the
+ * local checkout of its repository to its branch when that is safe, and returns where it stands in plain words (what
+ * changed, the last activity) for Claude to say first, with the previews and the missing pieces when recorded.
+ * One read of the pull request, its files and its commits.
+ */
+export declare function continueExploration(ctx: BridgeContext, a: {
+    ref: string;
+    checkout?: boolean | undefined;
+}): Promise<{
+    checkout: {
+        status: "already-on-it" | "switched" | "not-switched";
+        note: string;
+    };
+    continueLines: {
+        app: string;
+        terminal: string;
+    };
+    next: string;
+    missingPieces?: {
+        id: string;
+        title: string;
+    }[] | undefined;
+    ref: string;
+    number: number;
+    name: string;
+    product: string;
+    repo: string;
+    branch: string;
+    url: string;
+    status: import("@bridge-ds/core").ExplorationStatus;
+    statusLabel: string;
+    archived: boolean;
+    stage: "exploring" | "not-started" | "handed";
+    whereItStands: string;
+    activity: {
+        who: string;
+        what: string;
+        when: string;
+    }[];
+    changedFiles: string[] | null;
+    previews: {
+        app: keyof import("@bridge-ds/core").PreviewApps;
+        label: string;
+        url: string;
+    }[];
+}>;
+/** @deprecated The old name: "Promote to review" became "Done exploring" (doneExploring). */
+export declare const promoteExploration: typeof doneExploring;
+/** bridge_archive_exploration / `bridge explore archive|unarchive`: the archived label on the still open pull request. */
+export declare function archiveExploration(ctx: BridgeContext, a: {
+    ref: string;
+    archived?: boolean | undefined;
+}): Promise<{
+    next: string;
+    repo?: string | undefined;
+    ref: string;
+    number: number;
+    url: string;
+    branch: string;
+    archived: boolean;
+    status: "archived" | "unarchived";
 }>;
 export declare function closeExploration(ctx: BridgeContext, a: {
     ref: string;
 }): Promise<{
+    note: string;
+    repo?: string | undefined;
     number: number;
     url: string;
     branch: string;

package/dist/figma.d.ts

@@ -84,7 +84,7 @@ export declare function pushFigmaComponentOp(ctx: BridgeContext, a: {
     fixInFigma?: import("@bridge-ds/core").PushIssue[] | undefined;
     reasons?: string[] | undefined;
     edits?: import("@bridge-ds/core").TokenEdit[] | undefined;
-    status: "opened" | "suggested" | "dry-run" | "not-sent";
+    status: "suggested" | "opened" | "dry-run" | "not-sent";
     component: string;
     route: string;
     said: string;

package/dist/index.js

@@ -3,8 +3,8 @@ import {
   VERSION,
   optionsFromArgv,
   serveStdio
-} from "./chunk-E5V42VCS.js";
-import "./chunk-BZEPCY42.js";
+} from "./chunk-FRHGLK6Z.js";
+import "./chunk-HNGVASTJ.js";
 
 // src/index.ts
 var argv = process.argv.slice(2);

package/dist/lib.d.ts

@@ -1,6 +1,7 @@
 import { BridgeContext, type ContextOptions } from './context.js';
 import { type ServerOptions } from './server.js';
 export { BridgeContext, type ContextOptions } from './context.js';
+export { findProductLink, GIT_CONFIG_KEYS, linkedOptions, parseProductPointer, PRODUCT_POINTER, type ProductLink, type ProductPointer } from './product-link.js';
 export { BlockedError, isBlocked, say } from './say.js';
 export { createServer, SERVER_INFO, VERSION, type ServerOptions } from './server.js';
 export { CONFIG_FILE, detectConfig, parseConfig, toConfigJson, type BridgeConfig } from './config.js';

package/dist/lib.js

@@ -2,9 +2,11 @@ import {
   BlockedError,
   BridgeContext,
   DOCS_DRAFT_MODEL,
+  GIT_CONFIG_KEYS,
   GitHubSource,
   GitRefSource,
   LocalSource,
+  PRODUCT_POINTER,
   SERVER_INFO,
   VERSION,
   anthropicReplyText,
@@ -20,16 +22,19 @@ import {
   explorations_exports,
   figma_exports,
   figma_fixes_exports,
+  findProductLink,
   formatDocsJson,
   ghAuthToken,
   handleHttp,
   history_exports,
   isBlocked,
+  linkedOptions,
   mergeDocsDraft,
   missingProse,
   ops_exports,
   optionsFromArgv,
   parseDocsReply,
+  parseProductPointer,
   pieces_exports,
   requests_exports,
   say,
@@ -37,20 +42,22 @@ import {
   studio_exports,
   suggestions_exports,
   tokenNote
-} from "./chunk-E5V42VCS.js";
+} from "./chunk-FRHGLK6Z.js";
 import {
   CONFIG_FILE,
   loadConfig,
   toConfigJson
-} from "./chunk-BZEPCY42.js";
+} from "./chunk-HNGVASTJ.js";
 export {
   BlockedError,
   BridgeContext,
   CONFIG_FILE,
   DOCS_DRAFT_MODEL,
+  GIT_CONFIG_KEYS,
   GitHubSource,
   GitRefSource,
   LocalSource,
+  PRODUCT_POINTER,
   SERVER_INFO,
   VERSION,
   anthropicReplyText,
@@ -66,17 +73,20 @@ export {
   explorations_exports as explorations,
   figma_exports as figma,
   figma_fixes_exports as figmaFixes,
+  findProductLink,
   formatDocsJson,
   ghAuthToken,
   handleHttp,
   history_exports as history,
   isBlocked,
+  linkedOptions,
   mergeDocsDraft,
   missingProse,
   ops_exports as ops,
   optionsFromArgv,
   loadConfig as parseConfig,
   parseDocsReply,
+  parseProductPointer,
   pieces_exports as pieces,
   requests_exports as requests,
   say,

package/dist/pieces.d.ts

@@ -30,10 +30,12 @@ export declare function missingPiecesOp(ctx: BridgeContext, a: {
     recorded: boolean;
     next: string;
     skipped?: string | undefined;
-    pr: number;
     branch: string;
     product: string;
     files: number;
+    repo?: string | undefined;
+    pr: number;
+    ref: string;
 }>;
 /**
  * bridge_open_library_branch / `bridge pieces open <n> <piece>`: the library side of one recorded piece, linked both
@@ -57,13 +59,15 @@ export declare function openLibraryBranchOp(ctx: BridgeContext, a: {
         number: number;
         url: string;
     } | undefined;
-    changesMode: ChangesMode;
     neededBy: string;
+    ref?: string | undefined;
+    repo?: string | undefined;
+    changesMode: ChangesMode;
     request?: string | undefined;
     exploration?: string | undefined;
     brief?: string | undefined;
     edits?: import("@bridge-ds/core").TokenEdit[] | undefined;
-    status: "opened" | "suggested" | "already-linked" | "dry-run";
+    status: "suggested" | "opened" | "already-linked" | "dry-run";
     pr: number;
     piece: string;
     opens: string;
@@ -74,7 +78,6 @@ export declare function productBranchOp(ctx: BridgeContext, a: {
     pr: number | string;
 }): Promise<{
     next?: string | undefined;
-    pr: number;
     title: string;
     product: string;
     said: string;
@@ -102,6 +105,10 @@ export declare function productBranchOp(ctx: BridgeContext, a: {
         title: string;
         summary: string;
     }[];
+    ref?: string | undefined;
+    repo?: string | undefined;
+    library?: string | undefined;
+    pr: number;
 }>;
 /** bridge_use_library_preview: the product branch takes (again) the library branch of a piece, merged in. */
 export declare function useLibraryPreviewOp(ctx: BridgeContext, a: {

package/dist/product-link.d.ts

@@ -0,0 +1,42 @@
+import type { ContextOptions } from './context.js';
+/** Where the pointer lives, relative to the product repository root. */
+export declare const PRODUCT_POINTER = ".bridge/product.json";
+export interface ProductPointer {
+    version: 1;
+    /** The team's design system repository, `owner/name`, where bridge.config.json lives. */
+    designSystem: string;
+    /** The product key in that bridge.config.json `products[]`. */
+    product: string;
+}
+export interface ProductLink extends ProductPointer {
+    /** The product repository root: the folder holding `.bridge/product.json`. */
+    root: string;
+}
+/**
+ * The same link kept in the clone's own git config (`bridge.designSystem`, `bridge.product`, set by `bridge connect`):
+ * it survives switching to a branch made before the setup was committed, where `.bridge/product.json` is not.
+ */
+export declare const GIT_CONFIG_KEYS: {
+    readonly designSystem: "bridge.designSystem";
+    readonly product: "bridge.product";
+};
+/** The pointer from its JSON text, or why it cannot be read, in plain words. */
+export declare function parseProductPointer(text: string): ProductPointer;
+/**
+ * The connected product repository `dir` is in: the nearest folder at or above it with `.bridge/product.json`. A
+ * folder with its own bridge.config.json met first wins (it is a design system repository, not a product), and so
+ * does the end of the git repository (the folder holding `.git`): there the clone's git config may still keep the link
+ * (GIT_CONFIG_KEYS), else null.
+ */
+export declare function findProductLink(dir: string): Promise<ProductLink | null>;
+/**
+ * Context options for a command run in `dir`. In a connected product repository: the design system repository on
+ * GitHub (`repo`), this checkout (`workTree`) and its product key (`product`). Elsewhere `base` unchanged with `root`.
+ * An explicit `repo` (the MCP server's `--repo`) keeps it, and takes the checkout and product only when the pointer
+ * names that same repository.
+ */
+export declare function linkedOptions(dir: string, base?: Omit<ContextOptions, 'root'> & {
+    root?: string | undefined;
+}): Promise<ContextOptions & {
+    link?: ProductLink;
+}>;