@h-rig/contracts 0.0.6-alpha.154 → 0.0.6-alpha.156

package/dist/src/browser.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Pure browser-contract types.
+ *
+ * These types are the neutral home for the browser-required task contract so
+ * that the dumb runtime substrate (isolation provisioning, task info, rig-agent,
+ * rig-browser-tool) and the @rig/browser-plugin that owns the resolution logic
+ * can both reference them without a substrate->plugin import cycle. They carry
+ * no behaviour and import nothing — exactly like `memory.ts` /
+ * `lifecycle-capabilities.ts`.
+ *
+ * The plugin registers its executable `BrowserContractService` impl under
+ * {@link BROWSER_CONTRACT_SERVICE_CAPABILITY_ID} on `contributes.capabilities[].run`;
+ * the runtime resolves it by id from `pluginHost.listExecutableCapabilities()`
+ * via the typed port in `@rig/runtime/control-plane/browser-contract-port`.
+ */
+/** Capability id the browser plugin registers its `BrowserContractService` factory under. */
+export declare const BROWSER_CONTRACT_SERVICE_CAPABILITY_ID = "browser.contract";
+/** Author-facing browser config attached to a task entry (rig.config / task source). */
+export type TaskBrowserConfig = {
+    required?: boolean;
+    preset?: string;
+    profile?: string;
+    attach_url?: string;
+    state_dir?: string;
+    dev_command?: string;
+    launch_command?: string;
+    check_command?: string;
+    e2e_command?: string;
+    mode?: string;
+};
+/** Resolved, runtime-effective browser contract persisted into the runtime context. */
+export type RuntimeBrowserContext = {
+    required: boolean;
+    preset: string;
+    mode: string;
+    stateDir: string;
+    defaultProfile: string;
+    effectiveProfile: string;
+    defaultAttachUrl: string;
+    effectiveAttachUrl: string;
+    devCommand?: string;
+    launchCommand?: string;
+    checkCommand?: string;
+    e2eCommand?: string;
+    launchHelper: string;
+    checkHelper: string;
+    attachInfoHelper: string;
+    e2eHelper: string;
+    resetProfileHelper: string;
+};

package/dist/src/browser.js

@@ -0,0 +1,6 @@
+// @bun
+// packages/contracts/src/browser.ts
+var BROWSER_CONTRACT_SERVICE_CAPABILITY_ID = "browser.contract";
+export {
+  BROWSER_CONTRACT_SERVICE_CAPABILITY_ID
+};

package/dist/src/config.d.ts

@@ -388,6 +388,10 @@ export declare const RigConfig: Schema.Struct<{
                 readonly description: Schema.optional<Schema.String>;
                 readonly priority: Schema.optional<Schema.Number>;
             }>>>;
+            readonly sessionExtensions: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly description: Schema.optional<Schema.String>;
+            }>>>;
         }>>;
     }>>;
     readonly taskSource: Schema.Struct<{

package/dist/src/config.js

@@ -170,19 +170,6 @@ var CapabilityReplacementSpec = Schema3.Union([
   CapabilityReplacement,
   TrimmedNonEmptyString
 ]);
-var PluginMeta = Schema3.Struct({
-  id: TrimmedNonEmptyString,
-  version: TrimmedNonEmptyString,
-  provides: Schema3.Array(CapabilityTag),
-  requires: Schema3.optional(Schema3.Array(CapabilityTag)),
-  replaces: Schema3.optional(Schema3.Array(CapabilityReplacementSpec))
-});
-var LoadedPluginDescriptor = Schema3.Struct({
-  meta: PluginMeta,
-  provides: Schema3.Array(CapabilityTag),
-  contributes: Schema3.Unknown,
-  runtime: Schema3.Unknown
-});
 var KernelReplacementGrant = Schema3.Struct({
   pluginId: TrimmedNonEmptyString,
   grantedBy: Schema3.optional(TrimmedNonEmptyString),
@@ -327,6 +314,10 @@ var BlockerClassifierRegistration = Schema4.Struct({
   description: Schema4.optional(Schema4.String),
   priority: Schema4.optional(Schema4.Number)
 });
+var SessionExtensionRegistration = Schema4.Struct({
+  id: Schema4.String,
+  description: Schema4.optional(Schema4.String)
+});
 var PluginContributes = Schema4.Struct({
   validators: Schema4.optional(Schema4.Array(ValidatorRegistration)),
   hooks: Schema4.optional(Schema4.Array(HookRegistration)),
@@ -340,7 +331,8 @@ var PluginContributes = Schema4.Struct({
   stageMutations: Schema4.optional(Schema4.Array(StageMutation)),
   capabilities: Schema4.optional(Schema4.Array(ProductCapabilityRegistration)),
   panels: Schema4.optional(Schema4.Array(PanelRegistration)),
-  blockerClassifiers: Schema4.optional(Schema4.Array(BlockerClassifierRegistration))
+  blockerClassifiers: Schema4.optional(Schema4.Array(BlockerClassifierRegistration)),
+  sessionExtensions: Schema4.optional(Schema4.Array(SessionExtensionRegistration))
 });
 var RigPlugin = Schema4.Struct({
   name: Schema4.String,

package/dist/src/control-plane-types.d.ts

@@ -0,0 +1,283 @@
+/**
+ * Control-plane shared types.
+ *
+ * These types previously lived inside the runtime native PR/merge/verify
+ * lifecycle modules (pr-automation.ts, pr-review-gate.ts, verifier.ts) and
+ * were imported across module boundaries, creating mutual coupling. They are
+ * hoisted here — the bottom contracts layer — so the lifecycle plugins
+ * (@rig/pr-review-plugin, @rig/bundle-default-lifecycle) and the dumb runtime
+ * substrate (git-ops, task-ops) all reference one canonical definition without
+ * importing each other.
+ */
+export type GitHubCommandResult = {
+    readonly exitCode: number;
+    readonly stdout?: string;
+    readonly stderr?: string;
+};
+export type GitHubCommandRunner = (args: readonly string[], options?: {
+    readonly cwd?: string;
+}) => Promise<GitHubCommandResult>;
+export type GitCommandRunner = (args: readonly string[], options?: {
+    readonly cwd?: string;
+}) => Promise<GitHubCommandResult>;
+export type RigAutomationConfig = {
+    readonly automation?: {
+        readonly maxValidationAttempts?: number;
+        readonly maxPrFixIterations?: number;
+    };
+    readonly pr?: {
+        readonly mode?: "auto" | "ask" | "off";
+        readonly watchChecks?: boolean;
+        readonly autoFixChecks?: boolean;
+        readonly autoFixReview?: boolean;
+        readonly pendingTimeoutMs?: number;
+        readonly pendingPollMs?: number;
+    };
+    readonly merge?: {
+        readonly mode?: "auto" | "off" | "pr-ready";
+        readonly method?: "repo-default" | "squash" | "merge" | "rebase";
+        readonly deleteBranch?: "repo-default" | boolean;
+        readonly allowedFailures?: readonly string[];
+        readonly bypass?: boolean;
+    };
+    readonly review?: {
+        readonly mode?: "off" | "advisory" | "required";
+        readonly provider?: "greptile" | "github";
+    };
+};
+export type PrAutomationResult = {
+    readonly status: "skipped" | "opened" | "merged" | "needs_attention";
+    readonly prUrl?: string;
+    readonly iterations: number;
+    readonly actionableFeedback: readonly string[];
+    readonly merged?: boolean;
+};
+export type PrAutomationLifecycle = {
+    readonly onPrOpened?: (input: {
+        readonly prUrl: string;
+    }) => Promise<void> | void;
+    readonly onReviewCiStarted?: (input: {
+        readonly prUrl: string;
+        readonly iteration: number;
+    }) => Promise<void> | void;
+    readonly onFeedback?: (input: {
+        readonly prUrl: string;
+        readonly iteration: number;
+        readonly feedback: readonly string[];
+    }) => Promise<void> | void;
+    readonly onMergeStarted?: (input: {
+        readonly prUrl: string;
+    }) => Promise<void> | void;
+    readonly onMerged?: (input: {
+        readonly prUrl: string;
+    }) => Promise<void> | void;
+};
+export type GithubUser = {
+    readonly login?: string | null;
+} | null;
+export type GithubPullRequestReview = {
+    readonly id?: string | null;
+    readonly state?: string | null;
+    readonly body?: string | null;
+    readonly commit_id?: string | null;
+    readonly html_url?: string | null;
+    readonly author?: GithubUser;
+};
+export type GithubReviewThreadComment = {
+    readonly author?: GithubUser;
+    readonly body?: string | null;
+    readonly path?: string | null;
+    readonly url?: string | null;
+    readonly createdAt?: string | null;
+};
+export type GithubReviewThread = {
+    readonly id?: string | null;
+    readonly isResolved?: boolean | null;
+    readonly isOutdated?: boolean | null;
+    readonly comments?: {
+        readonly nodes?: readonly GithubReviewThreadComment[] | null;
+        readonly pageInfo?: {
+            readonly hasNextPage?: boolean | null;
+            readonly endCursor?: string | null;
+        } | null;
+    } | null;
+};
+export type GithubReviewComment = {
+    readonly id?: number | string | null;
+    readonly user?: GithubUser;
+    readonly author?: GithubUser;
+    readonly body?: string | null;
+    readonly path?: string | null;
+    readonly html_url?: string | null;
+    readonly url?: string | null;
+    readonly commit_id?: string | null;
+    readonly original_commit_id?: string | null;
+};
+export type GithubIssueComment = {
+    readonly id?: number | string | null;
+    readonly user?: GithubUser;
+    readonly author?: GithubUser;
+    readonly body?: string | null;
+    readonly html_url?: string | null;
+    readonly url?: string | null;
+    readonly created_at?: string | null;
+};
+export type PrCheckSummary = {
+    readonly name: string;
+    readonly status?: string | null;
+    readonly state?: string | null;
+    readonly conclusion?: string | null;
+    readonly detailsUrl?: string | null;
+};
+export type GithubStatusCheckRollupItem = PrCheckSummary & {
+    readonly __typename?: string | null;
+    readonly context?: string | null;
+    readonly detailsUrl?: string | null;
+    readonly link?: string | null;
+    readonly headSha?: string | null;
+    readonly head_sha?: string | null;
+    readonly output?: {
+        readonly title?: string | null;
+        readonly summary?: string | null;
+        readonly text?: string | null;
+    } | null;
+    readonly app?: {
+        readonly slug?: string | null;
+        readonly name?: string | null;
+        readonly owner?: GithubUser;
+    } | null;
+};
+export type GreptileScore = {
+    readonly value: number;
+    readonly scale: number;
+    readonly raw: string;
+};
+export type GreptileSignalSource = "api" | "github-review" | "github-check" | "changed-file-comment" | "issue-comment" | "review-thread" | "pr-body" | "pr-title";
+export type GreptileSignalVerdict = "approved" | "rejected" | "skipped" | "pending" | "failed" | "completed";
+export type GreptileSignalEvidence = {
+    readonly source: GreptileSignalSource;
+    readonly trusted: boolean;
+    readonly authorLogin?: string | null;
+    readonly reviewedSha?: string | null;
+    readonly current: boolean | null;
+    readonly stale: boolean;
+    readonly score?: GreptileScore | null;
+    readonly scores?: readonly GreptileScore[];
+    readonly explicitApproval?: boolean;
+    readonly verdict?: GreptileSignalVerdict | null;
+    readonly blocker?: boolean;
+    readonly actionable?: boolean;
+    readonly bodyExcerpt?: string;
+};
+export type GreptileApiSignalInput = {
+    readonly id?: string | null;
+    readonly body?: string | null;
+    readonly reviewedSha?: string | null;
+    readonly status?: string | null;
+};
+export type GreptileEvidence = {
+    readonly source: "api" | "github-review" | "github-check" | "github-comment" | "pr-body" | "combined" | "missing";
+    readonly currentHeadSha: string;
+    readonly reviewedSha?: string | null;
+    readonly fresh: boolean;
+    readonly completed: boolean;
+    readonly approved: boolean;
+    readonly score?: GreptileScore | null;
+    readonly explicitApproval?: boolean;
+    readonly blockers: readonly string[];
+    readonly unresolvedComments: readonly string[];
+    readonly rawBodies: readonly string[];
+    readonly signals: readonly GreptileSignalEvidence[];
+    readonly mapping: "score-5-of-5" | "explicit-approved" | "unproven" | "missing" | "stale";
+};
+export type PrReviewEvidence = {
+    readonly prUrl: string;
+    readonly prNumber: number;
+    readonly repoName: string;
+    readonly title: string;
+    readonly body: string;
+    readonly bodyEditorLogin?: string | null;
+    readonly bodyLastEditedAt?: string | null;
+    readonly headCommittedDate?: string | null;
+    readonly headSha: string;
+    readonly headRefName?: string | null;
+    readonly baseRefName?: string | null;
+    readonly state?: string | null;
+    readonly isDraft?: boolean | null;
+    readonly mergeable?: string | null;
+    readonly mergeStateStatus?: string | null;
+    readonly reviewDecision?: string | null;
+    readonly reviews: readonly GithubPullRequestReview[];
+    readonly reviewThreads: readonly GithubReviewThread[];
+    readonly changedFileReviewComments: readonly GithubReviewComment[];
+    readonly relevantIssueComments: readonly GithubIssueComment[];
+    readonly statusCheckRollup: readonly GithubStatusCheckRollupItem[];
+    readonly checkFailures: readonly string[];
+    readonly pendingChecks: readonly string[];
+    readonly readErrors: readonly string[];
+    readonly greptile: GreptileEvidence;
+};
+export type PrReviewCycleArtifacts = {
+    readonly root: string;
+    readonly prTitlePath: string;
+    readonly prBodyPath: string;
+    readonly prCommentsPath: string;
+    readonly reviewThreadsPath: string;
+    readonly reviewCommentsPath: string;
+    readonly checkRollupPath: string;
+    readonly greptileEvidencePath: string;
+    readonly mergeGateResultPath: string;
+    readonly steeringPromptPath: string;
+    readonly finalMergeGateResultPath?: string;
+};
+export type StrictPrMergeGateReasonCode = "read_error" | "missing_head_sha" | "ci_failed" | "check_pending" | "review_decision_blocking" | "review_thread_unresolved" | "greptile_missing" | "greptile_stale" | "greptile_pending" | "greptile_api_status_unknown" | "greptile_not_current_head" | "greptile_score_not_5" | "greptile_score_missing" | "greptile_mapping_unproven" | "greptile_blocker_text" | "greptile_unresolved_comment";
+export type StrictPrMergeGateReason = {
+    readonly code: StrictPrMergeGateReasonCode;
+    readonly reasonClass: "pending" | "reject";
+    readonly surface: "github" | "ci" | "review" | "greptile";
+    readonly suggestedAction: "wait" | "fix" | "ask_greptile" | "needs_attention";
+    readonly message: string;
+    readonly headSha?: string | null;
+    readonly reviewedSha?: string | null;
+};
+export type StrictPrMergeGateResult = {
+    readonly approved: boolean;
+    readonly pending: boolean;
+    readonly reasons: readonly string[];
+    readonly reasonDetails: readonly StrictPrMergeGateReason[];
+    readonly warnings: readonly string[];
+    readonly actionableFeedback: readonly string[];
+    readonly evidence: PrReviewEvidence;
+    readonly artifacts?: PrReviewCycleArtifacts;
+    readonly steeringPrompt: string;
+};
+export type StrictPrGreptileApiFetch = (input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => ReturnType<typeof fetch>;
+export type StrictPrGreptileApiOptions = {
+    readonly enabled?: boolean;
+    readonly env?: Record<string, string | undefined>;
+    readonly fetch?: StrictPrGreptileApiFetch;
+};
+export type StrictPrMergeGateInput = {
+    readonly projectRoot: string;
+    readonly prUrl: string;
+    readonly taskId: string;
+    readonly runId: string;
+    readonly cycle: number;
+    readonly command: GitHubCommandRunner;
+    readonly artifactRoot?: string | null;
+    readonly allowedFailures?: readonly string[];
+    readonly apiSignals?: readonly GreptileApiSignalInput[];
+    readonly greptileApi?: StrictPrGreptileApiOptions;
+    readonly final?: boolean;
+    readonly requireGreptile?: boolean;
+};
+export type VerifyOutcome = {
+    approved: boolean;
+    localReasons: string[];
+    aiReasons: string[];
+    aiWarnings: string[];
+    aiVerdict: "APPROVE" | "REJECT" | "SKIP";
+    reviewFeedbackPath: string;
+    reviewStatePath: string;
+};
+export declare function strictMergeHeadShaFromGate(result: StrictPrMergeGateResult, prUrl: string, requireGreptile?: boolean): string;

package/dist/src/control-plane-types.js

@@ -0,0 +1,29 @@
+// @bun
+// packages/contracts/src/control-plane-types.ts
+function strictMergeHeadShaFromGate(result, prUrl, requireGreptile = true) {
+  if (!result.approved) {
+    throw new Error(`Refusing to merge ${prUrl}: strict merge gate is not approved.`);
+  }
+  if (result.evidence.prUrl !== prUrl) {
+    throw new Error(`Refusing to merge ${prUrl}: strict merge gate evidence belongs to ${result.evidence.prUrl}.`);
+  }
+  const headSha = result.evidence.headSha?.trim();
+  if (!headSha) {
+    throw new Error(`Refusing to merge ${prUrl}: strict merge gate did not provide a current head SHA.`);
+  }
+  if (!/^[0-9a-f]{40}$/i.test(headSha)) {
+    throw new Error(`Refusing to merge ${prUrl}: strict merge gate head is not a raw 40-character commit SHA.`);
+  }
+  if (requireGreptile) {
+    if (!result.evidence.greptile.fresh || result.evidence.greptile.currentHeadSha !== headSha) {
+      throw new Error(`Refusing to merge ${prUrl}: strict merge gate approval is not tied to head ${headSha}.`);
+    }
+    if (result.evidence.greptile.mapping !== "score-5-of-5" && result.evidence.greptile.mapping !== "explicit-approved") {
+      throw new Error(`Refusing to merge ${prUrl}: strict merge gate mapping is ${result.evidence.greptile.mapping}.`);
+    }
+  }
+  return headSha;
+}
+export {
+  strictMergeHeadShaFromGate
+};

package/dist/src/doctor.d.ts

@@ -0,0 +1,27 @@
+/**
+ * doctor.ts — pure diagnostic vocabulary for the doctor product domain.
+ *
+ * The diagnostic implementation (toolchain probes, rig.config loadability,
+ * GitHub auth/permission checks, Pi/run/relay discovery, remediation copy)
+ * lives in @rig/doctor-plugin and is resolved by substrate consumers (CLI
+ * surface, rig-extension) through the typed port in
+ * `@rig/runtime/control-plane/doctor-service-port` under
+ * {@link DOCTOR_RUNNER_CAPABILITY_ID}. This file holds ONLY the pure types and
+ * pure helpers shared by producer and consumers — no IO, no plugin imports.
+ */
+/** The capability id the doctor plugin registers its runner under. */
+export declare const DOCTOR_RUNNER_CAPABILITY_ID = "doctor.runner";
+export type DoctorStatus = "pass" | "warn" | "fail";
+export type DoctorLevel = "ok" | "warn" | "fail";
+export type DoctorCheck = {
+    readonly id?: string;
+    readonly label: string;
+    readonly status?: DoctorStatus;
+    readonly level?: DoctorLevel;
+    readonly detail?: string;
+    readonly remediation?: string;
+};
+/** Normalize the legacy `level` field to the canonical `status`. */
+export declare function doctorLevelToStatus(level: DoctorLevel): DoctorStatus;
+/** Count checks that resolve to a `fail` status (across status/level shapes). */
+export declare function countDoctorFailures(checks: readonly DoctorCheck[]): number;

package/dist/src/doctor.js

@@ -0,0 +1,14 @@
+// @bun
+// packages/contracts/src/doctor.ts
+var DOCTOR_RUNNER_CAPABILITY_ID = "doctor.runner";
+function doctorLevelToStatus(level) {
+  return level === "ok" ? "pass" : level;
+}
+function countDoctorFailures(checks) {
+  return checks.filter((entry) => (entry.status ?? doctorLevelToStatus(entry.level ?? "warn")) === "fail").length;
+}
+export {
+  doctorLevelToStatus,
+  countDoctorFailures,
+  DOCTOR_RUNNER_CAPABILITY_ID
+};

package/dist/src/github.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Pure GitHub-provider contract types.
+ *
+ * This is the neutral home for the GitHub SCM-provider data model so that the
+ * @rig/github-provider-plugin (which owns the implementation), the
+ * @rig/task-sources-plugin (which consumes the credential-provider abstraction),
+ * and any future dumb runtime substrate can all reference the same vocabulary
+ * without a substrate->plugin import cycle. These types carry no behaviour and
+ * import nothing — exactly like `memory.ts` / `lifecycle-capabilities.ts`.
+ *
+ * The plugin registers its executable GitHub-provider service under
+ * {@link GITHUB_PROVIDER_CAPABILITY_ID} on `contributes.capabilities[].run`; a
+ * dumb substrate consumer would resolve it by id from a plugin host built from
+ * the project's rig.config via a typed port — the same seam shape proven by
+ * the memory/lifecycle capability ports. (Today the only substrate-facing
+ * GitHub primitive — reading a token from an env-pointed state file — stays in
+ * @rig/runtime/control-plane/github/token-env as a dumb reader; the policy that
+ * produces that token lives in this plugin.)
+ */
+/** Capability id the GitHub-provider plugin registers its service factory under. */
+export declare const GITHUB_PROVIDER_CAPABILITY_ID = "github.provider";
+export type GitHubCredentialPurpose = "selected-repo" | "admin-fallback";
+export type GitHubCredentialSource = "signed-in-user" | "host-admin-fallback";
+export type GitHubCredentialProviderOptions = {
+    /**
+     * Session-scoped tokens keyed as:
+     * `user:<userId>|repo:<owner>/<repo>|workspace:<workspaceId>`.
+     * This intentionally models the app/session auth boundary; host tokens are
+     * not used for normal selected-repo operations.
+     */
+    sessionTokens?: Readonly<Record<string, string>>;
+    hostToken?: string | null;
+};
+export type ResolveGitHubTokenInput = {
+    owner: string;
+    repo: string;
+    workspaceId: string;
+    userId?: string;
+    purpose: GitHubCredentialPurpose;
+};
+export type ResolvedGitHubToken = {
+    token: string;
+    source: GitHubCredentialSource;
+};
+export interface GitHubCredentialProvider {
+    resolveGitHubToken(input: ResolveGitHubTokenInput): Promise<ResolvedGitHubToken>;
+}
+/** Options the state-file-backed credential provider accepts. */
+export type GitHubStateCredentialProviderOptions = {
+    stateFile?: string;
+    stateDir?: string;
+};
+export type GitHubAuthStatus = {
+    readonly signedIn: boolean;
+    readonly login: string | null;
+    readonly userId: string | null;
+    readonly scopes: readonly string[];
+    readonly selectedRepo: string | null;
+    readonly oauthConfigured: boolean;
+    readonly tokenSource: "oauth-device" | "manual-token" | "env" | null;
+};
+export type GitHubUserInfo = {
+    readonly login: string;
+    readonly id: string;
+    readonly scopes?: readonly string[];
+};
+export type GitHubRepositoryProbe = {
+    readonly ok: boolean;
+    readonly owner: string;
+    readonly repo: string;
+    readonly status: number;
+    readonly authenticated: boolean;
+    readonly authenticationRequired: boolean;
+    readonly fullName: string | null;
+    readonly private: boolean | null;
+    readonly message: string;
+    readonly scopes: readonly string[];
+};
+export interface GitHubProjectSummary {
+    id: string;
+    number: number;
+    title: string;
+    url?: string;
+}
+export interface GitHubProjectStatusField {
+    id: string;
+    name: string;
+    options: Array<{
+        id: string;
+        name: string;
+    }>;
+}
+/**
+ * The executable surface the GitHub-provider capability `run()` returns. Kept
+ * intentionally narrow to the substrate-relevant seam (token resolution); the
+ * plugin's full API (OAuth device flow, Projects sync, issue analysis) is
+ * imported directly by above-runtime consumers and is not part of this port.
+ */
+export interface GitHubProviderService {
+    createCredentialProvider(options?: GitHubCredentialProviderOptions): GitHubCredentialProvider;
+}
+/** The capability `run` shape the plugin registers: a zero-arg service factory. */
+export type GitHubProviderServiceRun = () => GitHubProviderService;

package/dist/src/github.js

@@ -0,0 +1,6 @@
+// @bun
+// packages/contracts/src/github.ts
+var GITHUB_PROVIDER_CAPABILITY_ID = "github.provider";
+export {
+  GITHUB_PROVIDER_CAPABILITY_ID
+};

package/dist/src/help-catalog.js

@@ -313,7 +313,7 @@ var PRIMARY_GROUPS = [
     name: "graph",
     summary: "Workspace dependency graph.",
     usage: ["rig graph [--json|--dot]"],
-    commands: [{ command: "[--json|--dot]", description: "Build the dependency graph through @rig/client and print summary, JSON, or DOT.", primary: true }],
+    commands: [{ command: "[--json|--dot]", description: "Build the workspace dependency graph and print summary, JSON, or DOT.", primary: true }],
     examples: ["rig graph", "rig graph --json", "rig graph --dot"]
   },
   {

package/dist/src/index.d.ts

@@ -44,3 +44,14 @@ export * from "./supervisor-journal";
 export * from "./planning";
 export * from "./drift";
 export * from "./rollups";
+export * from "./panel-protocol";
+export * from "./control-plane-types";
+export * from "./lifecycle-capabilities";
+export * from "./browser";
+export * from "./memory";
+export * from "./provider-instructions";
+export * from "./isolation";
+export * from "./managed-repos";
+export * from "./task-graph-primitives";
+export * from "./github";
+export * from "./doctor";