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

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;