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

package/dist/src/notify.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Pure NOTIFY capability vocab.
+ *
+ * The neutral home for the notification event/target data types and the typed
+ * capability seam so the floor (and any consumer) can resolve a notifier off a
+ * plugin host WITHOUT importing the provider package. Carries no behaviour —
+ * exactly like `browser.ts` / `memory.ts`.
+ *
+ * `@rig/notifications-plugin` provides the concrete `NotifyService` impl
+ * (config load + target selection = policy) under
+ * {@link NOTIFY_SERVICE_CAPABILITY} via the `defineCapability` seam.
+ */
+import type { CapabilityId } from "./capability-id";
+/** A Rig lifecycle event eligible for outbound notification. */
+export type RigEvent = {
+    id?: string;
+    runId?: string;
+    timestamp?: string;
+    type: string;
+    payload?: Record<string, unknown>;
+};
+/** A configured outbound notification channel. */
+export type NotificationTarget = {
+    id: string;
+    type: "slack-webhook" | "linear-webhook" | "notion-webhook" | "generic-webhook";
+    url: string;
+    enabled?: boolean;
+    events?: string[];
+    headers?: Record<string, string>;
+};
+/** The on-disk notification policy (`.rig/notifications.json`). */
+export type NotificationConfig = {
+    targets: NotificationTarget[];
+};
+/** Capability id the notifications plugin registers its `NotifyService` under. */
+export declare const NOTIFY_SERVICE_CAPABILITY_ID = "notify.dispatch";
+/**
+ * The cohesive notify operation consumers depend on. The impl owns the policy:
+ * which targets receive which events, loaded from the project's
+ * `.rig/notifications.json`. Returns the count of targets successfully notified.
+ */
+export interface NotifyService {
+    notify(event: RigEvent): Promise<number>;
+}
+/** Typed capability id the notifications plugin provides and consumers require. */
+export declare const NOTIFY_SERVICE_CAPABILITY: CapabilityId<NotifyService>;

package/dist/src/notify.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/notify.ts
+var NOTIFY_SERVICE_CAPABILITY_ID = "notify.dispatch";
+var NOTIFY_SERVICE_CAPABILITY = makeCapabilityId(NOTIFY_SERVICE_CAPABILITY_ID);
+export {
+  NOTIFY_SERVICE_CAPABILITY_ID,
+  NOTIFY_SERVICE_CAPABILITY
+};

package/dist/src/orchestration.d.ts

@@ -0,0 +1,43 @@
+import { Schema } from "effect";
+export declare const ProviderKind: Schema.Literals<readonly ["codex", "claude"]>;
+export type ProviderKind = typeof ProviderKind.Type;
+export declare const ProviderApprovalPolicy: Schema.Literals<readonly ["untrusted", "on-failure", "on-request", "never"]>;
+export type ProviderApprovalPolicy = typeof ProviderApprovalPolicy.Type;
+export declare const ProviderSandboxMode: Schema.Literals<readonly ["read-only", "workspace-write", "danger-full-access"]>;
+export type ProviderSandboxMode = typeof ProviderSandboxMode.Type;
+export declare const ProviderServiceTier: Schema.Literals<readonly ["fast", "flex"]>;
+export type ProviderServiceTier = typeof ProviderServiceTier.Type;
+export declare const RuntimeMode: Schema.Literals<readonly ["approval-required", "full-access"]>;
+export type RuntimeMode = typeof RuntimeMode.Type;
+export declare const DEFAULT_RUNTIME_MODE: RuntimeMode;
+export declare const ProviderInteractionMode: Schema.Literals<readonly ["default", "plan"]>;
+export type ProviderInteractionMode = typeof ProviderInteractionMode.Type;
+export declare const DEFAULT_PROVIDER_INTERACTION_MODE: ProviderInteractionMode;
+export declare const ProviderRequestKind: Schema.Literals<readonly ["command", "file-read", "file-change"]>;
+export type ProviderRequestKind = typeof ProviderRequestKind.Type;
+export declare const ProviderApprovalDecision: Schema.Literals<readonly ["accept", "acceptForSession", "decline", "cancel"]>;
+export type ProviderApprovalDecision = typeof ProviderApprovalDecision.Type;
+export declare const ProviderUserInputAnswers: Schema.$Record<Schema.String, Schema.Unknown>;
+export type ProviderUserInputAnswers = typeof ProviderUserInputAnswers.Type;
+export declare const PROVIDER_SEND_TURN_MAX_INPUT_CHARS = 120000;
+export declare const PROVIDER_SEND_TURN_MAX_ATTACHMENTS = 8;
+export declare const PROVIDER_SEND_TURN_MAX_IMAGE_BYTES: number;
+declare const ChatAttachmentId: Schema.Trim;
+export type ChatAttachmentId = typeof ChatAttachmentId.Type;
+export declare const ChatImageAttachment: Schema.Struct<{
+    readonly type: Schema.Literal<"image">;
+    readonly id: Schema.Trim;
+    readonly name: Schema.Trim;
+    readonly mimeType: Schema.Trim;
+    readonly sizeBytes: Schema.Int;
+}>;
+export type ChatImageAttachment = typeof ChatImageAttachment.Type;
+export declare const ChatAttachment: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"image">;
+    readonly id: Schema.Trim;
+    readonly name: Schema.Trim;
+    readonly mimeType: Schema.Trim;
+    readonly sizeBytes: Schema.Int;
+}>]>;
+export type ChatAttachment = typeof ChatAttachment.Type;
+export {};

package/dist/src/orchestration.js

@@ -0,0 +1,98 @@
+// @bun
+// packages/contracts/src/orchestration.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/orchestration.ts
+var ProviderKind = Schema2.Literals(["codex", "claude"]);
+var ProviderApprovalPolicy = Schema2.Literals([
+  "untrusted",
+  "on-failure",
+  "on-request",
+  "never"
+]);
+var ProviderSandboxMode = Schema2.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var ProviderServiceTier = Schema2.Literals(["fast", "flex"]);
+var RuntimeMode = Schema2.Literals(["approval-required", "full-access"]);
+var DEFAULT_RUNTIME_MODE = "full-access";
+var ProviderInteractionMode = Schema2.Literals(["default", "plan"]);
+var DEFAULT_PROVIDER_INTERACTION_MODE = "default";
+var ProviderRequestKind = Schema2.Literals(["command", "file-read", "file-change"]);
+var ProviderApprovalDecision = Schema2.Literals([
+  "accept",
+  "acceptForSession",
+  "decline",
+  "cancel"
+]);
+var ProviderUserInputAnswers = Schema2.Record(Schema2.String, Schema2.Unknown);
+var PROVIDER_SEND_TURN_MAX_INPUT_CHARS = 120000;
+var PROVIDER_SEND_TURN_MAX_ATTACHMENTS = 8;
+var PROVIDER_SEND_TURN_MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+var CHAT_ATTACHMENT_ID_MAX_CHARS = 128;
+var ChatAttachmentId = TrimmedNonEmptyString.check(Schema2.isMaxLength(CHAT_ATTACHMENT_ID_MAX_CHARS), Schema2.isPattern(/^[a-z0-9_-]+$/i));
+var ChatImageAttachment = Schema2.Struct({
+  type: Schema2.Literal("image"),
+  id: ChatAttachmentId,
+  name: TrimmedNonEmptyString.check(Schema2.isMaxLength(255)),
+  mimeType: TrimmedNonEmptyString.check(Schema2.isMaxLength(100), Schema2.isPattern(/^image\//i)),
+  sizeBytes: NonNegativeInt.check(Schema2.isLessThanOrEqualTo(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES))
+});
+var ChatAttachment = Schema2.Union([ChatImageAttachment]);
+export {
+  RuntimeMode,
+  ProviderUserInputAnswers,
+  ProviderServiceTier,
+  ProviderSandboxMode,
+  ProviderRequestKind,
+  ProviderKind,
+  ProviderInteractionMode,
+  ProviderApprovalPolicy,
+  ProviderApprovalDecision,
+  PROVIDER_SEND_TURN_MAX_INPUT_CHARS,
+  PROVIDER_SEND_TURN_MAX_IMAGE_BYTES,
+  PROVIDER_SEND_TURN_MAX_ATTACHMENTS,
+  DEFAULT_RUNTIME_MODE,
+  DEFAULT_PROVIDER_INTERACTION_MODE,
+  ChatImageAttachment,
+  ChatAttachment
+};

package/dist/src/panel-protocol.d.ts

@@ -0,0 +1,17 @@
+import type { RunJournalProjection } from "./run-journal";
+/**
+ * Cross-package panel-protocol vocabulary shared by the run-worker (panel
+ * producer side) and the plugins that contribute the supervisor panel
+ * registration. Lives in @rig/contracts so neither side has to depend on the
+ * other's package for these constants.
+ */
+export declare const RIG_RUN_STOP_PANEL_ACTION = "rig-run:stop";
+export declare const RIG_CAPABILITY_PANEL_SLOT = "capability";
+export declare const RIG_SUPERVISOR_PANEL_ID = "supervisor";
+export interface WorkerPanelProducerContext {
+    readonly projectRoot: string;
+    readonly runId: string;
+    readonly folded: RunJournalProjection;
+    readonly taskIdAtStart?: string | null;
+    readonly runDisplayTitle: string;
+}

package/dist/src/panel-protocol.js

@@ -0,0 +1,10 @@
+// @bun
+// packages/contracts/src/panel-protocol.ts
+var RIG_RUN_STOP_PANEL_ACTION = "rig-run:stop";
+var RIG_CAPABILITY_PANEL_SLOT = "capability";
+var RIG_SUPERVISOR_PANEL_ID = "supervisor";
+export {
+  RIG_SUPERVISOR_PANEL_ID,
+  RIG_RUN_STOP_PANEL_ACTION,
+  RIG_CAPABILITY_PANEL_SLOT
+};

package/dist/src/pi-session.d.ts

@@ -0,0 +1,113 @@
+export type RigPiSessionTransport = "http-control-ws-events";
+export interface RigPiSessionMetadata {
+    runId: string;
+    sessionId: string;
+    daemonId: string;
+    cwd: string;
+    agentDir: string;
+    sessionDir: string;
+    transport: RigPiSessionTransport;
+    /**
+     * Absolute path of the Pi session jsonl backing this session, when the
+     * session persists to disk. Recorded on the run record so a tier-1
+     * re-dispatch (deploy-safe runs) can reopen the same session.
+     */
+    sessionFile?: string;
+    /**
+     * Set when the daemon reopened a previous attempt's session file instead
+     * of creating a fresh session (tier-1 session resume).
+     */
+    resumedFromSessionFile?: string;
+    serverBasePath: string;
+    eventsPath: string;
+    createdAt: string;
+    updatedAt: string;
+    backend: {
+        kind: "worker-pi-sessiond";
+        version: string;
+        pid?: number;
+        commit?: string;
+    };
+}
+export type RigPiDaemonConnection = {
+    mode: "unix";
+    socketPath: string;
+    tokenRef: string;
+    endpointId?: string;
+    hostId?: string;
+} | {
+    mode: "http";
+    baseUrl: string;
+    tokenRef: string;
+    endpointId?: string;
+    hostId?: string;
+};
+export interface RigPiSessionPrivateMetadata {
+    public: RigPiSessionMetadata;
+    daemonConnection: RigPiDaemonConnection;
+}
+export type RigPiControlStreamingBehavior = "steer" | "followUp";
+export interface RigPiPromptRequest {
+    text: string;
+    streamingBehavior?: RigPiControlStreamingBehavior;
+}
+export interface RigPiShellRequest {
+    text: string;
+}
+export interface RigPiCommandRequest {
+    text: string;
+}
+export interface RigPiCommandResponseRequest {
+    requestId: string;
+    value?: unknown;
+    cancelled?: boolean;
+}
+export interface RigPiExtensionUiResponseRequest {
+    requestId: string;
+    value?: unknown;
+    cancelled?: boolean;
+}
+export interface RigPiReadyPendingResponse {
+    ready: false;
+    runId: string;
+    status?: string;
+    retryAfterMs: number;
+}
+export interface RigPiReadyResponse {
+    ready: true;
+    metadata: RigPiSessionMetadata;
+}
+export type RigPiSessionResponse = RigPiReadyPendingResponse | RigPiReadyResponse;
+export type RigPiEventEnvelope = {
+    type: "ready";
+    metadata: RigPiSessionMetadata;
+} | {
+    type: "pi.event";
+    sessionId: string;
+    runId?: string;
+    event: unknown;
+} | {
+    type: "pi.ui_event";
+    sessionId: string;
+    runId?: string;
+    event: unknown;
+} | {
+    type: "extension_ui_request";
+    sessionId: string;
+    runId?: string;
+    request: unknown;
+} | {
+    type: "status.update";
+    sessionId: string;
+    runId?: string;
+    status: unknown;
+} | {
+    type: "activity.update";
+    sessionId: string;
+    runId?: string;
+    activity: unknown;
+} | {
+    type: "error";
+    message: string;
+    detail?: unknown;
+};

package/dist/src/pi-session.js

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

package/dist/src/placement.d.ts

@@ -0,0 +1,47 @@
+import type { CapabilityId } from "./capability-id";
+export type PlacementKind = "local" | "remote";
+export type Placement = {
+    readonly alias: string;
+    readonly kind: PlacementKind;
+    readonly host?: string | null;
+    readonly port?: number | null;
+    readonly baseUrl?: string | null;
+    readonly projectRoot?: string | null;
+    readonly status?: string | null;
+    readonly taskSource?: string | null;
+};
+export type AddPlacementInput = {
+    readonly alias: string;
+    readonly host: string;
+    readonly port?: number;
+    readonly token?: string | null;
+    readonly select?: boolean;
+};
+export interface PlacementService {
+    readonly readPlacement: (input: {
+        readonly projectRoot: string;
+    }) => Promise<Placement>;
+    readonly listPlacements: (input: {
+        readonly projectRoot: string;
+    }) => Promise<readonly Placement[]>;
+    readonly selectPlacement: (input: {
+        readonly projectRoot: string;
+        readonly alias: string;
+        readonly dryRun?: boolean;
+    }) => Promise<Placement>;
+    readonly addPlacement: (input: {
+        readonly projectRoot: string;
+        readonly placement: AddPlacementInput;
+        readonly dryRun?: boolean;
+    }) => Promise<Placement>;
+    readonly removePlacement: (input: {
+        readonly projectRoot: string;
+        readonly alias: string;
+        readonly dryRun?: boolean;
+    }) => Promise<{
+        readonly alias: string;
+        readonly removed: boolean;
+    }>;
+}
+export declare const PLACEMENT_SERVICE_CAPABILITY_ID = "rig.transport.placement";
+export declare const PLACEMENT_SERVICE: CapabilityId<PlacementService>;

package/dist/src/placement.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/placement.ts
+var PLACEMENT_SERVICE_CAPABILITY_ID = "rig.transport.placement";
+var PLACEMENT_SERVICE = makeCapabilityId(PLACEMENT_SERVICE_CAPABILITY_ID);
+export {
+  PLACEMENT_SERVICE_CAPABILITY_ID,
+  PLACEMENT_SERVICE
+};

package/dist/src/planning.d.ts

@@ -0,0 +1,64 @@
+import { Schema } from "effect";
+export declare const ClarificationStatus: Schema.Literals<readonly ["open", "resolved-from-code", "resolved-by-human", "deferred"]>;
+export type ClarificationStatus = typeof ClarificationStatus.Type;
+export declare const OpenQuestion: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly question: Schema.Trim;
+    readonly status: Schema.Literals<readonly ["open", "resolved-from-code", "resolved-by-human", "deferred"]>;
+    readonly resolution: Schema.NullOr<Schema.String>;
+}>;
+export type OpenQuestion = typeof OpenQuestion.Type;
+export declare const UserStory: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly title: Schema.Trim;
+    readonly priority: Schema.Int;
+}>;
+export type UserStory = typeof UserStory.Type;
+export declare const FunctionalRequirement: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly text: Schema.Trim;
+}>;
+export type FunctionalRequirement = typeof FunctionalRequirement.Type;
+export declare const PlanTask: Schema.Struct<{
+    readonly localId: Schema.Trim;
+    readonly title: Schema.Trim;
+    readonly description: Schema.String;
+    readonly acceptance: Schema.$Array<Schema.String>;
+    readonly scope: Schema.$Array<Schema.Trim>;
+    readonly validationKeys: Schema.$Array<Schema.Trim>;
+    readonly dependsOn: Schema.$Array<Schema.Trim>;
+    readonly parent: Schema.NullOr<Schema.Trim>;
+    readonly parallelizable: Schema.Boolean;
+}>;
+export type PlanTask = typeof PlanTask.Type;
+export declare const PlanSpec: Schema.Struct<{
+    readonly prdTitle: Schema.Trim;
+    readonly userStories: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly title: Schema.Trim;
+        readonly priority: Schema.Int;
+    }>>;
+    readonly functionalRequirements: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly text: Schema.Trim;
+    }>>;
+    readonly openQuestions: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.Trim;
+        readonly question: Schema.Trim;
+        readonly status: Schema.Literals<readonly ["open", "resolved-from-code", "resolved-by-human", "deferred"]>;
+        readonly resolution: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly tasks: Schema.$Array<Schema.Struct<{
+        readonly localId: Schema.Trim;
+        readonly title: Schema.Trim;
+        readonly description: Schema.String;
+        readonly acceptance: Schema.$Array<Schema.String>;
+        readonly scope: Schema.$Array<Schema.Trim>;
+        readonly validationKeys: Schema.$Array<Schema.Trim>;
+        readonly dependsOn: Schema.$Array<Schema.Trim>;
+        readonly parent: Schema.NullOr<Schema.Trim>;
+        readonly parallelizable: Schema.Boolean;
+    }>>;
+    readonly generatedAt: Schema.String;
+}>;
+export type PlanSpec = typeof PlanSpec.Type;

package/dist/src/planning.js

@@ -0,0 +1,90 @@
+// @bun
+// packages/contracts/src/planning.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/planning.ts
+var ClarificationStatus = Schema2.Literals([
+  "open",
+  "resolved-from-code",
+  "resolved-by-human",
+  "deferred"
+]);
+var OpenQuestion = Schema2.Struct({
+  id: TrimmedNonEmptyString,
+  question: TrimmedNonEmptyString,
+  status: ClarificationStatus,
+  resolution: Schema2.NullOr(Schema2.String)
+});
+var UserStory = Schema2.Struct({
+  id: TrimmedNonEmptyString,
+  title: TrimmedNonEmptyString,
+  priority: PositiveInt
+});
+var FunctionalRequirement = Schema2.Struct({
+  id: TrimmedNonEmptyString,
+  text: TrimmedNonEmptyString
+});
+var PlanTask = Schema2.Struct({
+  localId: TrimmedNonEmptyString,
+  title: TrimmedNonEmptyString,
+  description: Schema2.String,
+  acceptance: Schema2.Array(Schema2.String),
+  scope: Schema2.Array(TrimmedNonEmptyString),
+  validationKeys: Schema2.Array(TrimmedNonEmptyString),
+  dependsOn: Schema2.Array(TrimmedNonEmptyString),
+  parent: Schema2.NullOr(TrimmedNonEmptyString),
+  parallelizable: Schema2.Boolean
+});
+var PlanSpec = Schema2.Struct({
+  prdTitle: TrimmedNonEmptyString,
+  userStories: Schema2.Array(UserStory),
+  functionalRequirements: Schema2.Array(FunctionalRequirement),
+  openQuestions: Schema2.Array(OpenQuestion),
+  tasks: Schema2.Array(PlanTask),
+  generatedAt: IsoDateTime
+});
+export {
+  UserStory,
+  PlanTask,
+  PlanSpec,
+  OpenQuestion,
+  FunctionalRequirement,
+  ClarificationStatus
+};

package/dist/src/plugin-hooks.d.ts

@@ -0,0 +1,51 @@
+import { Schema } from "effect";
+/** Tool input payload as delivered on the hook's stdin (`tool_input`). */
+export declare const HookToolInput: Schema.$Record<Schema.String, Schema.Unknown>;
+export type HookToolInput = typeof HookToolInput.Type;
+/**
+ * Parsed hook invocation handed to a typed hook implementation.
+ *
+ * Derived from the Claude Code hook stdin payload (see
+ * @rig/core/hook-protocol's `readHookInput`) plus the runner's resolved
+ * environment:
+ * - `event`        — the lifecycle event the hook fired on
+ * - `toolName`     — `tool_name` from the payload (absent for non-tool events)
+ * - `toolInput`    — `tool_input` from the payload (`{}` when absent)
+ * - `filePaths`    — file path candidates extracted from the tool input
+ * - `projectRoot`  — resolved project root
+ * - `taskId`       — current Rig task id, `""` when not running inside a task
+ */
+export declare const HookContext: Schema.Struct<{
+    readonly event: Schema.Literals<readonly ["PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop", "SessionStart", "SessionEnd"]>;
+    readonly toolName: Schema.optional<Schema.String>;
+    readonly toolInput: Schema.$Record<Schema.String, Schema.Unknown>;
+    readonly filePaths: Schema.$Array<Schema.String>;
+    readonly projectRoot: Schema.String;
+    readonly taskId: Schema.String;
+}>;
+export type HookContext = typeof HookContext.Type;
+export declare const HookDecision: Schema.Literals<readonly ["allow", "block"]>;
+export type HookDecision = typeof HookDecision.Type;
+/**
+ * Result returned by a typed hook implementation.
+ *
+ * Serialized to the same stdout/exit-code protocol that
+ * @rig/core/hook-protocol's `block()` uses:
+ * - `decision: "block"` → `BLOCKED: <reason>` on stdout, non-zero exit
+ * - `decision: "allow"` → exit 0; `systemMessage` (when set) on stdout
+ */
+export declare const HookResult: Schema.Struct<{
+    readonly decision: Schema.Literals<readonly ["allow", "block"]>;
+    /** Why the action was blocked. Surfaced to the agent on stdout. */
+    readonly reason: Schema.optional<Schema.String>;
+    /** Extra context printed on stdout for either decision. */
+    readonly systemMessage: Schema.optional<Schema.String>;
+}>;
+export type HookResult = typeof HookResult.Type;
+/**
+ * A typed hook implementation. Registered per hook id via definePlugin's
+ * plugin object: `definePlugin(meta, { hooks: { [hookId]: impl } })`.
+ * Functions can't be represented by Schema, so this is a plain type — the
+ * referential-integrity rules are enforced by @rig/core's definePlugin.
+ */
+export type HookImplementation = (input: HookContext) => Promise<HookResult> | HookResult;