@h-rig/contracts 0.0.0-e2e-live.20260630085347

package/dist/src/agent-roles.d.ts

@@ -0,0 +1,8 @@
+import type { AgentRoleRegistration } from "./plugin";
+export interface ResolvedAgentRole extends AgentRoleRegistration {
+    model: string;
+}
+export interface AgentRoleRegistry {
+    resolve(id: string): ResolvedAgentRole;
+    list(): readonly ResolvedAgentRole[];
+}

package/dist/src/agent-roles.js

@@ -0,0 +1 @@
+// @bun

package/dist/src/artifact.d.ts

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+export declare const ArtifactSummary: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "ArtifactId">;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly taskId: Schema.NullOr<Schema.brand<Schema.Trim, "TaskId">>;
+    readonly kind: Schema.Trim;
+    readonly label: Schema.Trim;
+    readonly path: Schema.NullOr<Schema.Trim>;
+    readonly url: Schema.NullOr<Schema.Trim>;
+    readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly createdAt: Schema.String;
+}>;
+export type ArtifactSummary = typeof ArtifactSummary.Type;

package/dist/src/artifact.js

@@ -0,0 +1,56 @@
+// @bun
+// packages/contracts/src/artifact.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/artifact.ts
+var ArtifactSummary = Schema2.Struct({
+  id: ArtifactId,
+  runId: RunId,
+  taskId: Schema2.NullOr(TaskId),
+  kind: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  path: Schema2.NullOr(TrimmedNonEmptyString),
+  url: Schema2.NullOr(TrimmedNonEmptyString),
+  metadata: Schema2.Record(Schema2.String, Schema2.Unknown),
+  createdAt: IsoDateTime
+});
+export {
+  ArtifactSummary
+};

package/dist/src/baseSchemas.d.ts

@@ -0,0 +1,63 @@
+import { Schema } from "effect";
+export declare const TrimmedString: Schema.Trim;
+export declare const TrimmedNonEmptyString: Schema.Trim;
+export declare const NonNegativeInt: Schema.Int;
+export declare const PositiveInt: Schema.Int;
+export declare const IsoDateTime: Schema.String;
+export type IsoDateTime = typeof IsoDateTime.Type;
+export declare const ThreadId: Schema.brand<Schema.Trim, "ThreadId">;
+export type ThreadId = typeof ThreadId.Type;
+export declare const ProjectId: Schema.brand<Schema.Trim, "ProjectId">;
+export type ProjectId = typeof ProjectId.Type;
+export declare const WorkspaceId: Schema.brand<Schema.Trim, "WorkspaceId">;
+export type WorkspaceId = typeof WorkspaceId.Type;
+export declare const GraphId: Schema.brand<Schema.Trim, "GraphId">;
+export type GraphId = typeof GraphId.Type;
+export declare const TaskId: Schema.brand<Schema.Trim, "TaskId">;
+export type TaskId = typeof TaskId.Type;
+export declare const RunId: Schema.brand<Schema.Trim, "RunId">;
+export type RunId = typeof RunId.Type;
+export declare const SafePathSegment: Schema.brand<Schema.Trim, "SafePathSegment">;
+export type SafePathSegment = typeof SafePathSegment.Type;
+export declare const SafeRunId: Schema.brand<Schema.Trim, "SafeRunId">;
+export type SafeRunId = typeof SafeRunId.Type;
+export declare const SafeGitRefComponent: Schema.brand<Schema.Trim, "SafeGitRefComponent">;
+export type SafeGitRefComponent = typeof SafeGitRefComponent.Type;
+export declare const EngineRuntimeId: Schema.brand<Schema.Trim, "EngineRuntimeId">;
+export type EngineRuntimeId = typeof EngineRuntimeId.Type;
+export declare const ConversationId: Schema.brand<Schema.Trim, "ConversationId">;
+export type ConversationId = typeof ConversationId.Type;
+export declare const ActionId: Schema.brand<Schema.Trim, "ActionId">;
+export type ActionId = typeof ActionId.Type;
+export declare const ArtifactId: Schema.brand<Schema.Trim, "ArtifactId">;
+export type ArtifactId = typeof ArtifactId.Type;
+export declare const WorktreeId: Schema.brand<Schema.Trim, "WorktreeId">;
+export type WorktreeId = typeof WorktreeId.Type;
+export declare const ValidationResultId: Schema.brand<Schema.Trim, "ValidationResultId">;
+export type ValidationResultId = typeof ValidationResultId.Type;
+export declare const ReviewResultId: Schema.brand<Schema.Trim, "ReviewResultId">;
+export type ReviewResultId = typeof ReviewResultId.Type;
+export declare const CommandId: Schema.brand<Schema.Trim, "CommandId">;
+export type CommandId = typeof CommandId.Type;
+export declare const EventId: Schema.brand<Schema.Trim, "EventId">;
+export type EventId = typeof EventId.Type;
+export declare const MessageId: Schema.brand<Schema.Trim, "MessageId">;
+export type MessageId = typeof MessageId.Type;
+export declare const TurnId: Schema.brand<Schema.Trim, "TurnId">;
+export type TurnId = typeof TurnId.Type;
+export declare const ProviderItemId: Schema.brand<Schema.Trim, "ProviderItemId">;
+export type ProviderItemId = typeof ProviderItemId.Type;
+export declare const RuntimeSessionId: Schema.brand<Schema.Trim, "RuntimeSessionId">;
+export type RuntimeSessionId = typeof RuntimeSessionId.Type;
+export declare const RuntimeItemId: Schema.brand<Schema.Trim, "RuntimeItemId">;
+export type RuntimeItemId = typeof RuntimeItemId.Type;
+export declare const RuntimeRequestId: Schema.brand<Schema.Trim, "RuntimeRequestId">;
+export type RuntimeRequestId = typeof RuntimeRequestId.Type;
+export declare const RuntimeTaskId: Schema.brand<Schema.Trim, "RuntimeTaskId">;
+export type RuntimeTaskId = typeof RuntimeTaskId.Type;
+export declare const ApprovalRequestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+export type ApprovalRequestId = typeof ApprovalRequestId.Type;
+export declare const CheckpointRef: Schema.brand<Schema.Trim, "CheckpointRef">;
+export type CheckpointRef = typeof CheckpointRef.Type;
+export declare const RemoteEndpointId: Schema.brand<Schema.Trim, "RemoteEndpointId">;
+export type RemoteEndpointId = typeof RemoteEndpointId.Type;

package/dist/src/baseSchemas.js

@@ -0,0 +1,72 @@
+// @bun
+// 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");
+export {
+  WorktreeId,
+  WorkspaceId,
+  ValidationResultId,
+  TurnId,
+  TrimmedString,
+  TrimmedNonEmptyString,
+  ThreadId,
+  TaskId,
+  SafeRunId,
+  SafePathSegment,
+  SafeGitRefComponent,
+  RuntimeTaskId,
+  RuntimeSessionId,
+  RuntimeRequestId,
+  RuntimeItemId,
+  RunId,
+  ReviewResultId,
+  RemoteEndpointId,
+  ProviderItemId,
+  ProjectId,
+  PositiveInt,
+  NonNegativeInt,
+  MessageId,
+  IsoDateTime,
+  GraphId,
+  EventId,
+  EngineRuntimeId,
+  ConversationId,
+  CommandId,
+  CheckpointRef,
+  ArtifactId,
+  ApprovalRequestId,
+  ActionId
+};

package/dist/src/blocker-classifier.d.ts

@@ -0,0 +1,21 @@
+import type { CapabilityId } from "./capability-id";
+import type { BlockerClassification } from "./graph";
+import type { RunRecord } from "./run-record";
+import type { TaskLike } from "./task-source";
+export interface WorkspaceBlockersProjection {
+    readonly classifications: readonly BlockerClassification[];
+    readonly human: readonly BlockerClassification[];
+    readonly machine: readonly BlockerClassification[];
+    readonly generatedAt: string;
+}
+export interface BlockerClassifierService {
+    readonly classifyTasks: (input: {
+        readonly tasks: readonly TaskLike[];
+        readonly runs?: readonly Pick<RunRecord, "taskId" | "status" | "updatedAt" | "startedAt">[];
+        readonly humanOnly?: boolean;
+        readonly generatedAt?: string;
+    }) => WorkspaceBlockersProjection;
+    readonly isHumanBlockerClass: (blockerClass: BlockerClassification["blockerClass"]) => boolean;
+}
+export declare const BLOCKER_CLASSIFIER_CAPABILITY_ID = "rig.blockers.classifier";
+export declare const BLOCKER_CLASSIFIER: CapabilityId<BlockerClassifierService>;

package/dist/src/blocker-classifier.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/blocker-classifier.ts
+var BLOCKER_CLASSIFIER_CAPABILITY_ID = "rig.blockers.classifier";
+var BLOCKER_CLASSIFIER = makeCapabilityId(BLOCKER_CLASSIFIER_CAPABILITY_ID);
+export {
+  BLOCKER_CLASSIFIER_CAPABILITY_ID,
+  BLOCKER_CLASSIFIER
+};

package/dist/src/browser.d.ts

@@ -0,0 +1,80 @@
+/**
+ * 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 the
+ * typed capability id {@link BROWSER_CONTRACT_SERVICE_CAPABILITY} (whose string
+ * value is {@link BROWSER_CONTRACT_SERVICE_CAPABILITY_ID}) via the
+ * `defineCapability` seam (`@rig/core/capability`); the runtime resolves it by id
+ * from `pluginHost.listExecutableCapabilities()` via the thin typed port in
+ * `@rig/runtime/control-plane/browser-contract-port`.
+ */
+import type { CapabilityId } from "./capability-id";
+/** 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;
+};
+/** Options for deriving the runtime-effective browser context. */
+export type ResolveTaskBrowserContextOptions = {
+    hostProjectRoot?: string;
+    runtimeId?: string;
+};
+/**
+ * The cohesive set of browser-contract operations the runtime consumers depend
+ * on. This is pure capability VOCAB: the `@rig/browser-plugin` provides a
+ * concrete impl (statically checked against this interface via
+ * `BrowserContractCap.provide`), and the substrate only ever sees this contract —
+ * resolved by id off a plugin host with no `as unknown as` at any call site.
+ */
+export interface BrowserContractService {
+    /** Resolve an author-facing `TaskBrowserConfig` into the runtime-effective context. */
+    resolveTaskBrowserContext(browser: TaskBrowserConfig | undefined, options?: ResolveTaskBrowserContextOptions): RuntimeBrowserContext | undefined;
+    /** Render the `task info` guidance lines for a resolved browser context. */
+    buildBrowserGuidanceLines(browser: RuntimeBrowserContext): string[];
+}
+/**
+ * The typed capability id the browser plugin provides and consumers require.
+ * Phantom-typed with {@link BrowserContractService} so
+ * `BrowserContractCap.require(host)` returns a `BrowserContractService` with no
+ * cast leaking to callers. Its string value is
+ * {@link BROWSER_CONTRACT_SERVICE_CAPABILITY_ID}, so it indexes the same host
+ * entry.
+ */
+export declare const BROWSER_CONTRACT_SERVICE_CAPABILITY: CapabilityId<BrowserContractService>;

package/dist/src/browser.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/browser.ts
+var BROWSER_CONTRACT_SERVICE_CAPABILITY_ID = "browser.contract";
+var BROWSER_CONTRACT_SERVICE_CAPABILITY = makeCapabilityId(BROWSER_CONTRACT_SERVICE_CAPABILITY_ID);
+export {
+  BROWSER_CONTRACT_SERVICE_CAPABILITY_ID,
+  BROWSER_CONTRACT_SERVICE_CAPABILITY
+};

package/dist/src/capability-id.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Capability-seam vocabulary.
+ *
+ * A `CapabilityId<T>` is a plain id string branded (phantom-typed) with the
+ * service type `T` it resolves to. `defineCapability<T>` (in `@rig/core`) reads
+ * this brand so `resolve`/`require` are typed as `T` with the `unknown → T` cast
+ * contained ONCE inside the helper — callers never cast.
+ *
+ * Pure: no imports, no behaviour. The brand lives only in an OPTIONAL phantom
+ * property so a plain `string` is still assignable to `CapabilityId<T>` via the
+ * `makeCapabilityId` cast, and a `CapabilityId<T>` is usable anywhere a `string`
+ * is (equality checks against `host` capability ids, `.toString()`, etc.).
+ */
+declare const CapabilityIdBrand: unique symbol;
+/** A capability id string branded with the service type `T` it resolves to. */
+export type CapabilityId<T> = string & {
+    /** Phantom — never present at runtime; carries `T` for `defineCapability<T>`. */
+    readonly [CapabilityIdBrand]?: T;
+};
+/** Brand a plain id string as a `CapabilityId<T>`. */
+export declare function makeCapabilityId<T>(id: string): CapabilityId<T>;
+export {};

package/dist/src/capability-id.js

@@ -0,0 +1,8 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+export {
+  makeCapabilityId
+};