@h-rig/contracts 0.0.6-alpha.18 → 0.0.6-alpha.181

package/dist/src/review.d.ts

@@ -0,0 +1,18 @@
+import { Schema } from "effect";
+export declare const ReviewMode: Schema.Literals<readonly ["off", "advisory", "required"]>;
+export type ReviewMode = typeof ReviewMode.Type;
+export declare const ReviewStatus: Schema.Literals<readonly ["pending", "running", "approved", "rejected", "error"]>;
+export type ReviewStatus = typeof ReviewStatus.Type;
+export declare const ReviewSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "ReviewResultId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly provider: Schema.Trim;
+    readonly mode: Schema.Literals<readonly ["off", "advisory", "required"]>;
+    readonly status: Schema.Literals<readonly ["pending", "running", "approved", "rejected", "error"]>;
+    readonly summary: Schema.NullOr<Schema.String>;
+    readonly output: Schema.Unknown;
+    readonly createdAt: Schema.String;
+    readonly completedAt: Schema.NullOr<Schema.String>;
+}>;
+export type ReviewSummary = typeof ReviewSummary.Type;

package/dist/src/review.js

@@ -16,6 +16,9 @@ var WorkspaceId = makeEntityId("WorkspaceId");
 var GraphId = makeEntityId("GraphId");
 var TaskId = makeEntityId("TaskId");
 var RunId = makeEntityId("RunId");
+var SafePathSegment = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafePathSegment"));
+var SafeRunId = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(Schema.brand("SafeRunId"));
+var SafeGitRefComponent = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafeGitRefComponent"));
 var EngineRuntimeId = makeEntityId("EngineRuntimeId");
 var ConversationId = makeEntityId("ConversationId");
 var ActionId = makeEntityId("ActionId");

package/dist/src/rollups.d.ts

@@ -0,0 +1,41 @@
+import { Schema } from "effect";
+export declare const PercentComplete: Schema.Int;
+export type PercentComplete = typeof PercentComplete.Type;
+export declare const EpicRollup: Schema.Struct<{
+    readonly epicKey: Schema.Trim;
+    readonly total: Schema.Int;
+    readonly percentComplete: Schema.Int;
+    readonly blockedCount: Schema.Int;
+    readonly humanBlockedCount: Schema.Int;
+    readonly inFlightCount: Schema.Int;
+    readonly byStatus: Schema.$Record<Schema.String, Schema.Int>;
+}>;
+export type EpicRollup = typeof EpicRollup.Type;
+export declare const AssigneeRollup: Schema.Struct<{
+    readonly assignee: Schema.Trim;
+    readonly openTaskCount: Schema.Int;
+    readonly inFlightRunCount: Schema.Int;
+    readonly prsAwaitingReview: Schema.Int;
+    readonly blockers: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
+}>;
+export type AssigneeRollup = typeof AssigneeRollup.Type;
+export declare const WorkspaceRollups: Schema.Struct<{
+    readonly epics: Schema.$Array<Schema.Struct<{
+        readonly epicKey: Schema.Trim;
+        readonly total: Schema.Int;
+        readonly percentComplete: Schema.Int;
+        readonly blockedCount: Schema.Int;
+        readonly humanBlockedCount: Schema.Int;
+        readonly inFlightCount: Schema.Int;
+        readonly byStatus: Schema.$Record<Schema.String, Schema.Int>;
+    }>>;
+    readonly assignees: Schema.$Array<Schema.Struct<{
+        readonly assignee: Schema.Trim;
+        readonly openTaskCount: Schema.Int;
+        readonly inFlightRunCount: Schema.Int;
+        readonly prsAwaitingReview: Schema.Int;
+        readonly blockers: Schema.$Array<Schema.brand<Schema.Trim, "TaskId">>;
+    }>>;
+    readonly generatedAt: Schema.String;
+}>;
+export type WorkspaceRollups = typeof WorkspaceRollups.Type;

package/dist/src/rollups.js

@@ -0,0 +1,70 @@
+// @bun
+// packages/contracts/src/rollups.ts
+import { Schema as Schema2 } from "effect";
+
+// packages/contracts/src/baseSchemas.ts
+import { Schema } from "effect";
+var TrimmedString = Schema.Trim;
+var TrimmedNonEmptyString = TrimmedString.check(Schema.isNonEmpty());
+var NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+var PositiveInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1));
+var IsoDateTime = Schema.String;
+var makeEntityId = (brand) => TrimmedNonEmptyString.pipe(Schema.brand(brand));
+var ThreadId = makeEntityId("ThreadId");
+var ProjectId = makeEntityId("ProjectId");
+var WorkspaceId = makeEntityId("WorkspaceId");
+var GraphId = makeEntityId("GraphId");
+var TaskId = makeEntityId("TaskId");
+var RunId = makeEntityId("RunId");
+var SafePathSegment = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafePathSegment"));
+var SafeRunId = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(Schema.brand("SafeRunId"));
+var SafeGitRefComponent = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafeGitRefComponent"));
+var EngineRuntimeId = makeEntityId("EngineRuntimeId");
+var ConversationId = makeEntityId("ConversationId");
+var ActionId = makeEntityId("ActionId");
+var ArtifactId = makeEntityId("ArtifactId");
+var WorktreeId = makeEntityId("WorktreeId");
+var ValidationResultId = makeEntityId("ValidationResultId");
+var ReviewResultId = makeEntityId("ReviewResultId");
+var CommandId = makeEntityId("CommandId");
+var EventId = makeEntityId("EventId");
+var MessageId = makeEntityId("MessageId");
+var TurnId = makeEntityId("TurnId");
+var ProviderItemId = makeEntityId("ProviderItemId");
+var RuntimeSessionId = makeEntityId("RuntimeSessionId");
+var RuntimeItemId = makeEntityId("RuntimeItemId");
+var RuntimeRequestId = makeEntityId("RuntimeRequestId");
+var RuntimeTaskId = makeEntityId("RuntimeTaskId");
+var ApprovalRequestId = makeEntityId("ApprovalRequestId");
+var CheckpointRef = makeEntityId("CheckpointRef");
+var RemoteEndpointId = makeEntityId("RemoteEndpointId");
+
+// packages/contracts/src/rollups.ts
+var PercentComplete = NonNegativeInt.check(Schema2.isLessThanOrEqualTo(100));
+var EpicRollup = Schema2.Struct({
+  epicKey: TrimmedNonEmptyString,
+  total: NonNegativeInt,
+  percentComplete: PercentComplete,
+  blockedCount: NonNegativeInt,
+  humanBlockedCount: NonNegativeInt,
+  inFlightCount: NonNegativeInt,
+  byStatus: Schema2.Record(Schema2.String, NonNegativeInt)
+});
+var AssigneeRollup = Schema2.Struct({
+  assignee: TrimmedNonEmptyString,
+  openTaskCount: NonNegativeInt,
+  inFlightRunCount: NonNegativeInt,
+  prsAwaitingReview: NonNegativeInt,
+  blockers: Schema2.Array(TaskId)
+});
+var WorkspaceRollups = Schema2.Struct({
+  epics: Schema2.Array(EpicRollup),
+  assignees: Schema2.Array(AssigneeRollup),
+  generatedAt: IsoDateTime
+});
+export {
+  WorkspaceRollups,
+  PercentComplete,
+  EpicRollup,
+  AssigneeRollup
+};

package/dist/src/run-control.d.ts

@@ -0,0 +1,164 @@
+/**
+ * run-control.ts - typed run control capability vocabulary.
+ *
+ * RUN_READ_MODEL is projection-oriented. Operators that plan launches, deliver
+ * control frames, resolve inbox requests, compute resume actions, or remove
+ * registry entries use this control seam instead of mutating through read-model
+ * consumers.
+ */
+import type { CapabilityId } from "./capability-id";
+import type { RunDiscoveryFilter } from "./run-discovery";
+import type { RunRecord } from "./run-record";
+import type { RunInboxResolutionInit } from "./run-session-journal";
+export type RunControl = {
+    readonly kind: "steer";
+    readonly message: string;
+} | {
+    readonly kind: "stop";
+    readonly reason: string;
+} | {
+    readonly kind: "pause";
+} | {
+    readonly kind: "resume";
+};
+export interface RunControlTargetInput {
+    readonly projectRoot: string;
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    readonly taskId?: string | null;
+    readonly purpose?: "attach" | "steer" | "stop" | "pause" | "resume" | "restart" | "delete" | "prune" | "resolve-inbox";
+    readonly discoveryFilter?: RunDiscoveryFilter;
+}
+export interface RunControlTarget {
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    readonly taskId: string | null;
+    readonly sessionId: string | null;
+    readonly sessionPath: string | null;
+    readonly joinLink: string | null;
+    readonly webLink: string | null;
+    readonly relayUrl: string | null;
+    readonly collabCwd: string | null;
+    readonly live: boolean;
+    readonly stale: boolean;
+    readonly canDeliver: boolean;
+    readonly reason?: string | null;
+}
+export interface RunControlInput {
+    readonly projectRoot: string;
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    readonly control: RunControl;
+    readonly requestedBy?: string | null;
+    readonly discoveryFilter?: RunDiscoveryFilter;
+}
+export interface RunControlResult {
+    readonly runId: string;
+    readonly kind: RunControl["kind"];
+    readonly status: "delivered" | "not-found" | "not-live" | "unsupported";
+    readonly delivered: boolean;
+    readonly detail?: string | null;
+}
+export interface RunInboxResolutionInput {
+    readonly projectRoot: string;
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    readonly resolution: RunInboxResolutionInit;
+    readonly requestedBy?: string | null;
+    readonly discoveryFilter?: RunDiscoveryFilter;
+}
+export interface RunInboxResolutionResult {
+    readonly runId: string;
+    readonly requestId: string;
+    readonly kind: "approval" | "input";
+    readonly status: "resolved" | "not-found" | "not-live" | "unsupported";
+    readonly delivered: boolean;
+    readonly detail?: string | null;
+}
+export interface RunResumePlanInput {
+    readonly projectRoot: string;
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    readonly discoveryFilter?: RunDiscoveryFilter;
+}
+export interface RunLaunchCandidate {
+    readonly taskId: string;
+    readonly title?: string | null;
+}
+export interface RunLaunchPlanInput {
+    readonly projectRoot: string;
+    readonly candidates: readonly RunLaunchCandidate[];
+    /** Force means all candidates remain launchable; owners may still annotate results. */
+    readonly force?: boolean;
+    readonly discoveryFilter?: RunDiscoveryFilter;
+}
+export type RunLaunchPlanEntry = {
+    readonly kind: "launch";
+    readonly taskId: string;
+    readonly title: string | null;
+} | {
+    readonly kind: "skipped";
+    readonly taskId: string;
+    readonly title: string | null;
+    readonly reason: string;
+    readonly activeRunId?: string | null;
+};
+export interface RunLaunchPlan {
+    readonly entries: readonly RunLaunchPlanEntry[];
+    readonly launch: readonly Extract<RunLaunchPlanEntry, {
+        readonly kind: "launch";
+    }>[];
+    readonly skipped: readonly Extract<RunLaunchPlanEntry, {
+        readonly kind: "skipped";
+    }>[];
+    readonly force: boolean;
+}
+export type RunResumePlan = {
+    readonly kind: "deliver-control";
+    readonly runId: string;
+    readonly run: RunRecord;
+} | {
+    readonly kind: "redispatch-task";
+    readonly runId: string;
+    readonly taskId: string;
+    readonly title: string;
+} | {
+    readonly kind: "unavailable";
+    readonly runId: string;
+    readonly reason: string;
+};
+export interface RunRegistryRemovalInput {
+    readonly projectRoot: string;
+    /** Canonical run id/session id. */
+    readonly runId: string;
+}
+export interface RunRegistryRemovalResult {
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    readonly removed: boolean;
+}
+export interface RunDeadPidReconciliationInput {
+    readonly projectRoot: string;
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    readonly sessionPath: string;
+    readonly reason?: "lazy-reconcile:dead-pid";
+}
+export interface RunDeadPidReconciliationResult {
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    readonly updated: boolean;
+    readonly status: "reconciled" | "not-found" | "unavailable";
+    readonly detail?: string | null;
+}
+export interface RunControlService {
+    readonly resolveControlTarget: (input: RunControlTargetInput) => Promise<RunControlTarget | null>;
+    readonly deliverControl: (input: RunControlInput) => Promise<RunControlResult>;
+    readonly resolveInboxRequest: (input: RunInboxResolutionInput) => Promise<RunInboxResolutionResult>;
+    readonly planLaunches: (input: RunLaunchPlanInput) => Promise<RunLaunchPlan>;
+    readonly resolveResumePlan: (input: RunResumePlanInput) => Promise<RunResumePlan | null>;
+    readonly removeRunRegistryEntry: (input: RunRegistryRemovalInput) => Promise<RunRegistryRemovalResult>;
+    readonly reconcileDeadPid: (input: RunDeadPidReconciliationInput) => Promise<RunDeadPidReconciliationResult>;
+}
+export declare const RUN_CONTROL_CAPABILITY_ID = "rig.runs.control";
+export declare const RUN_CONTROL: CapabilityId<RunControlService>;

package/dist/src/run-control.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/run-control.ts
+var RUN_CONTROL_CAPABILITY_ID = "rig.runs.control";
+var RUN_CONTROL = makeCapabilityId(RUN_CONTROL_CAPABILITY_ID);
+export {
+  RUN_CONTROL_CAPABILITY_ID,
+  RUN_CONTROL
+};

package/dist/src/run-discovery.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Run-discovery capability seam.
+ *
+ * Contracts-native types for the RUN_DISCOVERY service: inline structural
+ * equivalents of the @oh-my-pi and @rig/relay-registry types. We define
+ * them here rather than importing from those packages to keep @rig/contracts
+ * floor-neutral (@rig/relay-registry depends on @rig/contracts — importing
+ * relay-registry here would be circular; @oh-my-pi is a vendor package that
+ * doesn't belong on the floor).
+ *
+ * TypeScript's structural type system makes these compatible with the
+ * corresponding @oh-my-pi / relay-registry types at the impl site.
+ *
+ * Pure: types + one branded id, no behaviour.
+ */
+import type { CapabilityId } from "./capability-id";
+import type { Stream } from "effect";
+/** Structural equivalent of @oh-my-pi CollabRegistryFilter. */
+export interface RunDiscoveryFilter {
+    githubUserId?: string;
+    namespaceKey?: string;
+    selectedRepo?: string;
+    cwd?: string;
+}
+export type RunRuntimeActivePredicate = (status: unknown) => boolean;
+export interface RunDiscoveryStaleOptions {
+    readonly isRuntimeActiveStatus?: RunRuntimeActivePredicate;
+}
+/** Structural equivalent of @oh-my-pi LiveCollabOwner. */
+export interface RunDiscoveryOwner {
+    githubUserId?: string;
+    login?: string;
+    namespaceKey?: string;
+}
+/** Structural equivalent of @oh-my-pi LiveCollabProjection. */
+export interface LiveRunCollabProjection {
+    sessionId: string;
+    sessionPath: string;
+    cwd: string;
+    title: string;
+    joinLink: string;
+    webLink: string;
+    relayUrl?: string;
+    owner?: RunDiscoveryOwner;
+    selectedRepo?: string;
+    startedAt: string;
+    updatedAt: string;
+    pid?: number;
+    stale: boolean;
+}
+/** Input for attaching to a run via the relay (structural equiv of AttachViaRelayInput). */
+export interface RigRunAttachInput {
+    readonly runId: string;
+    readonly taskId?: string | null;
+    readonly identityFilter: RunDiscoveryFilter;
+    readonly timeoutMs?: number;
+    readonly projectRoot?: string;
+}
+/** Result of a relay attach (structural equiv of RigExtensionAttachResult). */
+export interface RigRunAttachResult {
+    readonly sessionPath: string | null;
+    readonly joinLink: string | null;
+    readonly collabSessionId: string | null;
+}
+/**
+ * The run-discovery service surface: the unified active-run list (local FS +
+ * remote registry) and relay attach. registrySnapshotStream is intentionally
+ * omitted — its entry type (`RegistrySnapshotFrame` from @rig/relay-registry)
+ * cannot be referenced here without creating a circular dep; consumers that
+ * need snapshot frames must cast through the transport-plugin's richer type.
+ */
+export interface RunDiscoveryService {
+    readonly listActiveRunCollab: (projectRoot: string, filter: RunDiscoveryFilter, options?: RunDiscoveryStaleOptions) => Promise<readonly LiveRunCollabProjection[]>;
+    readonly runDiscoveryStream: (projectRoot: string) => Stream.Stream<void>;
+    readonly attachViaRelay: (input: RigRunAttachInput) => Promise<RigRunAttachResult | null>;
+}
+/** Stable id string for the run-discovery service capability. */
+export declare const RUN_DISCOVERY_CAPABILITY_ID = "rig.runs.discovery";
+/**
+ * The branded run-discovery capability id. `defineCapability(RUN_DISCOVERY)`
+ * (provider and consumers independently) resolves to a `RunDiscoveryService`.
+ */
+export declare const RUN_DISCOVERY: CapabilityId<RunDiscoveryService>;

package/dist/src/run-discovery.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/run-discovery.ts
+var RUN_DISCOVERY_CAPABILITY_ID = "rig.runs.discovery";
+var RUN_DISCOVERY = makeCapabilityId(RUN_DISCOVERY_CAPABILITY_ID);
+export {
+  RUN_DISCOVERY_CAPABILITY_ID,
+  RUN_DISCOVERY
+};

package/dist/src/run-dispatch.d.ts

@@ -0,0 +1,34 @@
+/**
+ * run-dispatch.ts — pure capability vocabulary for placement-aware run dispatch.
+ *
+ * The dispatch IMPL (local + remote placement, run-process spawn, session-id
+ * wait) lives in @rig/transport-plugin (`./dispatch`, the `transport` backbone).
+ * Programmatic consumers (rig-extension, supervisor) resolve it off a project's
+ * plugin host under {@link RUN_DISPATCH_CAPABILITY_ID} — WITHOUT importing the
+ * transport plugin's impl. This file holds ONLY the pure id + interface shared
+ * by the provider and its consumers (no IO, no plugin imports).
+ */
+import type { CapabilityId } from "./capability-id";
+/** The placement-aware run dispatch input (plain, OMP-type-free). */
+export interface RunDispatchInput {
+    readonly projectRoot: string;
+    readonly taskId: string;
+    readonly title?: string | null;
+    readonly model?: string | null;
+    readonly prompt?: string | null;
+    readonly force?: boolean;
+}
+/**
+ * The host-resolved run-dispatch surface: dispatch a run (resolving local vs
+ * remote/fleet placement at dispatch time) and resolve once an OMP session id
+ * has appeared. Mirrors `dispatchRun` in @rig/transport-plugin.
+ */
+export interface RunDispatchService {
+    readonly dispatchRun: (input: RunDispatchInput) => Promise<{
+        readonly runId: string;
+    }>;
+}
+/** The capability id the transport plugin registers its run dispatcher under. */
+export declare const RUN_DISPATCH_CAPABILITY_ID = "rig.runs.dispatch";
+/** Phantom-typed id; string value is {@link RUN_DISPATCH_CAPABILITY_ID}. */
+export declare const RUN_DISPATCH: CapabilityId<RunDispatchService>;

package/dist/src/run-dispatch.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/run-dispatch.ts
+var RUN_DISPATCH_CAPABILITY_ID = "rig.runs.dispatch";
+var RUN_DISPATCH = makeCapabilityId(RUN_DISPATCH_CAPABILITY_ID);
+export {
+  RUN_DISPATCH_CAPABILITY_ID,
+  RUN_DISPATCH
+};

package/dist/src/run-identity.d.ts

@@ -0,0 +1,47 @@
+/**
+ * cap:run-identity-env — GitHub/Rig run identity capability seam.
+ *
+ * The CLI seed and sibling plugins must not implement GitHub identity policy or
+ * import a provider implementation directly. The identity owner
+ * (`@rig/github-provider-plugin`) registers this capability with public
+ * identity-env hydration, run-child credential stripping, and runtime identity
+ * resolution. This file holds ONLY pure seam vocabulary — no IO.
+ */
+import type { CapabilityId } from "./capability-id";
+import type { RigIdentityContext, RigResolvedIdentity } from "./identity";
+/** Structural mirror of `@rig/relay-registry`'s `CollabRegistryFilter` (no transport dep). */
+export type IdentityRegistryFilter = {
+    readonly cwd?: string;
+    readonly selectedRepo?: string;
+    readonly githubUserId?: string;
+    readonly namespaceKey?: string;
+};
+/** Capability id the identity owner registers its run identity policy under. */
+export declare const RUN_IDENTITY_ENV_CAPABILITY_ID = "cap:run-identity-env";
+/** GitHub/Rig identity operations consumers resolve through the provider capability. */
+export interface RunIdentityEnvService {
+    /**
+     * Resolve public identity env vars for `workspaceRoot` without mutating
+     * process.env.
+     */
+    resolveIdentityEnv(workspaceRoot: string): Partial<Record<"RIG_SELECTED_REPO" | "RIG_GITHUB_USER_ID" | "RIG_GITHUB_LOGIN" | "RIG_GITHUB_NAMESPACE_KEY", string>>;
+    /**
+     * Hydrate the public-identity env vars for `workspaceRoot` into process.env
+     * (RIG_SELECTED_REPO / RIG_GITHUB_USER_ID / RIG_GITHUB_LOGIN / namespace key /
+     * auth-state-file pointer). Returns a restore closure that reverts the change.
+     */
+    applyIdentityEnv(workspaceRoot: string): () => void;
+    /** Build a registry discovery filter from the current public identity env. */
+    identityFilterFromEnv(): IdentityRegistryFilter;
+    /**
+     * Return a copy of `env` (default process.env) with the run-scoped credential
+     * tokens removed, for use as a spawned run-host child's environment.
+     */
+    stripRunChildCredentialEnv(env?: Record<string, string | undefined>): Record<string, string | undefined>;
+    /** Resolve the current Rig run identity from the OMP session/auth context. */
+    resolveRigIdentity(ctx: RigIdentityContext): RigResolvedIdentity | null;
+    /** Resolve the registry filter corresponding to the current Rig run identity. */
+    resolveRigIdentityFilter(ctx: RigIdentityContext): IdentityRegistryFilter | null;
+}
+/** Typed capability id; string value is {@link RUN_IDENTITY_ENV_CAPABILITY_ID}. */
+export declare const RUN_IDENTITY_ENV: CapabilityId<RunIdentityEnvService>;

package/dist/src/run-identity.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/run-identity.ts
+var RUN_IDENTITY_ENV_CAPABILITY_ID = "cap:run-identity-env";
+var RUN_IDENTITY_ENV = makeCapabilityId(RUN_IDENTITY_ENV_CAPABILITY_ID);
+export {
+  RUN_IDENTITY_ENV_CAPABILITY_ID,
+  RUN_IDENTITY_ENV
+};