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

package/dist/src/supervisor-journal.js

@@ -0,0 +1,336 @@
+// @bun
+// packages/contracts/src/supervisor-journal.ts
+import { Schema as Schema4 } 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/runtime.ts
+import { Schema as Schema3 } from "effect";
+
+// packages/contracts/src/orchestration.ts
+import { Schema as Schema2 } from "effect";
+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 ProviderInteractionMode = Schema2.Literals(["default", "plan"]);
+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_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]);
+
+// packages/contracts/src/runtime.ts
+var RunKind = Schema3.Literals(["adhoc", "task", "batch", "validation", "review"]);
+var RunMode = Schema3.Literals(["interactive", "autonomous", "supervised"]);
+var RunStatus = Schema3.Literals([
+  "created",
+  "queued",
+  "preparing",
+  "running",
+  "waiting-approval",
+  "waiting-user-input",
+  "paused",
+  "validating",
+  "reviewing",
+  "closing-out",
+  "needs-attention",
+  "completed",
+  "failed",
+  "stopped"
+]);
+var EngineSandboxMode = Schema3.Literals([
+  "read-only",
+  "workspace-write",
+  "danger-full-access"
+]);
+var IsolationMode = Schema3.Literals(["none", "env", "worktree"]);
+var RuntimeStatus = Schema3.Literals([
+  "prepared",
+  "starting",
+  "running",
+  "interrupted",
+  "exited",
+  "failed",
+  "destroyed"
+]);
+var RunExecutionTarget = Schema3.Literals(["local", "remote"]);
+var RunSummary = Schema3.Struct({
+  id: RunId,
+  workspaceId: WorkspaceId,
+  taskId: Schema3.NullOr(TaskId),
+  title: TrimmedNonEmptyString,
+  runKind: RunKind,
+  mode: RunMode,
+  runtimeMode: RuntimeMode,
+  interactionMode: ProviderInteractionMode,
+  status: RunStatus,
+  runtimeAdapter: Schema3.Literal("pi"),
+  model: Schema3.NullOr(TrimmedNonEmptyString),
+  initialPrompt: Schema3.NullOr(Schema3.String),
+  executionTarget: Schema3.optional(RunExecutionTarget),
+  remoteHostId: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseId: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  remoteLeaseClaimedAt: Schema3.optional(Schema3.NullOr(IsoDateTime)),
+  activeRuntimeId: Schema3.NullOr(EngineRuntimeId),
+  latestMessageId: Schema3.NullOr(TrimmedNonEmptyString),
+  pendingApprovalCount: NonNegativeInt,
+  pendingUserInputCount: NonNegativeInt,
+  branch: Schema3.NullOr(TrimmedNonEmptyString),
+  worktreePath: Schema3.NullOr(TrimmedNonEmptyString),
+  errorText: Schema3.NullOr(Schema3.String),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime,
+  startedAt: Schema3.NullOr(IsoDateTime),
+  completedAt: Schema3.NullOr(IsoDateTime)
+});
+var RuntimeSummary = Schema3.Struct({
+  id: EngineRuntimeId,
+  workspaceId: WorkspaceId,
+  runId: RunId,
+  adapterKind: Schema3.Literal("pi"),
+  executionTarget: Schema3.optional(RunExecutionTarget),
+  remoteHostId: Schema3.optional(Schema3.NullOr(TrimmedNonEmptyString)),
+  status: RuntimeStatus,
+  sandboxMode: EngineSandboxMode,
+  isolationMode: IsolationMode,
+  workspaceDir: Schema3.NullOr(TrimmedNonEmptyString),
+  homeDir: Schema3.NullOr(TrimmedNonEmptyString),
+  tmpDir: Schema3.NullOr(TrimmedNonEmptyString),
+  cacheDir: Schema3.NullOr(TrimmedNonEmptyString),
+  logsDir: Schema3.NullOr(TrimmedNonEmptyString),
+  stateDir: Schema3.NullOr(TrimmedNonEmptyString),
+  sessionDir: Schema3.NullOr(TrimmedNonEmptyString),
+  sessionLogPath: Schema3.NullOr(TrimmedNonEmptyString),
+  pid: Schema3.NullOr(NonNegativeInt),
+  startedAt: Schema3.NullOr(IsoDateTime),
+  updatedAt: IsoDateTime,
+  exitedAt: Schema3.NullOr(IsoDateTime)
+});
+var ApprovalStatus = Schema3.Literals(["pending", "resolved"]);
+var ApprovalSummary = Schema3.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  actionId: Schema3.NullOr(TrimmedNonEmptyString),
+  requestKind: TrimmedNonEmptyString,
+  status: ApprovalStatus,
+  payload: Schema3.Unknown,
+  createdAt: IsoDateTime,
+  resolvedAt: Schema3.NullOr(IsoDateTime)
+});
+var UserInputRequestSummary = Schema3.Struct({
+  id: TrimmedNonEmptyString,
+  runId: RunId,
+  status: ApprovalStatus,
+  payload: Schema3.Unknown,
+  createdAt: IsoDateTime,
+  resolvedAt: Schema3.NullOr(IsoDateTime)
+});
+var WorktreeSummary = Schema3.Struct({
+  id: WorktreeId,
+  workspaceId: WorkspaceId,
+  runId: RunId,
+  taskId: Schema3.NullOr(TaskId),
+  branchName: TrimmedNonEmptyString,
+  path: TrimmedNonEmptyString,
+  status: TrimmedNonEmptyString,
+  createdAt: IsoDateTime,
+  cleanedAt: Schema3.NullOr(IsoDateTime)
+});
+
+// packages/contracts/src/supervisor-journal.ts
+var SupervisorStopReason = Schema4.Literals([
+  "all-done",
+  "all-human-blocked",
+  "blocked",
+  "work-pending",
+  "max-tasks",
+  "budget",
+  "judge-stop",
+  "operator-stop",
+  "source-error"
+]);
+var SupervisorSelectionPolicy = Schema4.Literals(["rank", "max-unblock", "blocking-only"]);
+var SupervisorStatus = Schema4.Literals(["running", "idle", "stopped", "finished"]);
+var TaskClosureSummary = Schema4.Struct({
+  taskId: TaskId,
+  runId: RunId,
+  prUrl: Schema4.NullOr(Schema4.String),
+  mergeGate: Schema4.NullOr(Schema4.Literals(["passed", "blocked", "skipped"])),
+  acceptanceChecked: Schema4.Array(Schema4.Struct({
+    item: Schema4.String,
+    met: Schema4.Boolean
+  })),
+  unblockedTaskIds: Schema4.Array(TaskId)
+});
+var SupervisorStartedEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.started"),
+  at: IsoDateTime,
+  options: Schema4.Unknown
+});
+var SupervisorSelectionPlannedEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.selection-planned"),
+  at: IsoDateTime,
+  taskIds: Schema4.Array(TaskId),
+  policy: SupervisorSelectionPolicy
+});
+var SupervisorDispatchStartedEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.dispatch-started"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  score: NonNegativeInt
+});
+var SupervisorDispatchConfirmedEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.dispatch-confirmed"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  runId: RunId,
+  dispatchHandle: Schema4.optional(Schema4.NullOr(Schema4.String))
+});
+var SupervisorDispatchEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.dispatch"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  runId: RunId,
+  score: NonNegativeInt,
+  dispatchHandle: Schema4.optional(Schema4.NullOr(Schema4.String))
+});
+var SupervisorOutcomeEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.outcome"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  runId: RunId,
+  status: RunStatus,
+  failed: Schema4.Boolean,
+  unblockedTaskIds: Schema4.Array(TaskId),
+  closure: Schema4.optional(TaskClosureSummary)
+});
+var SupervisorSkippedEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.skipped"),
+  at: IsoDateTime,
+  taskId: TaskId,
+  reason: Schema4.String
+});
+var SupervisorIdleEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.idle"),
+  at: IsoDateTime,
+  reason: SupervisorStopReason
+});
+var SupervisorStoppedEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.stopped"),
+  at: IsoDateTime,
+  reason: SupervisorStopReason
+});
+var SupervisorFinishedEvent = Schema4.Struct({
+  kind: Schema4.Literal("supervisor.finished"),
+  at: IsoDateTime,
+  processed: NonNegativeInt,
+  succeeded: NonNegativeInt,
+  failed: NonNegativeInt,
+  skipped: Schema4.optional(NonNegativeInt),
+  idleReason: Schema4.NullOr(SupervisorStopReason)
+});
+var SupervisorEvent = Schema4.Union([
+  SupervisorStartedEvent,
+  SupervisorSelectionPlannedEvent,
+  SupervisorDispatchStartedEvent,
+  SupervisorDispatchConfirmedEvent,
+  SupervisorDispatchEvent,
+  SupervisorOutcomeEvent,
+  SupervisorSkippedEvent,
+  SupervisorIdleEvent,
+  SupervisorStoppedEvent,
+  SupervisorFinishedEvent
+]);
+var SupervisorProjection = Schema4.Struct({
+  status: SupervisorStatus,
+  processed: NonNegativeInt,
+  succeeded: NonNegativeInt,
+  failed: NonNegativeInt,
+  skipped: NonNegativeInt,
+  current: Schema4.NullOr(Schema4.Struct({ taskId: TaskId, runId: RunId })),
+  plannedOrder: Schema4.Array(TaskId),
+  selectionPolicy: Schema4.NullOr(SupervisorSelectionPolicy),
+  concurrency: Schema4.NullOr(NonNegativeInt),
+  idleReason: Schema4.NullOr(SupervisorStopReason),
+  stopReason: Schema4.NullOr(SupervisorStopReason),
+  closures: Schema4.Array(TaskClosureSummary),
+  anomalies: Schema4.Array(Schema4.String)
+});
+export {
+  TaskClosureSummary,
+  SupervisorStoppedEvent,
+  SupervisorStopReason,
+  SupervisorStatus,
+  SupervisorStartedEvent,
+  SupervisorSkippedEvent,
+  SupervisorSelectionPolicy,
+  SupervisorSelectionPlannedEvent,
+  SupervisorProjection,
+  SupervisorOutcomeEvent,
+  SupervisorIdleEvent,
+  SupervisorFinishedEvent,
+  SupervisorEvent,
+  SupervisorDispatchStartedEvent,
+  SupervisorDispatchEvent,
+  SupervisorDispatchConfirmedEvent
+};

package/dist/src/supervisor-loop.d.ts

@@ -0,0 +1,40 @@
+/**
+ * supervisor-loop.ts — typed service boundary for autonomous supervisor control.
+ *
+ * The supervisor plugin owns loop orchestration. Its implementation resolves the
+ * scheduler RUN_QUEUE, run read-model, and transport dispatch capabilities rather
+ * than making CLI surfaces assemble those cross-package decisions.
+ */
+import type { CapabilityId } from "./capability-id";
+import type { SupervisorEvent, SupervisorProjection, SupervisorSelectionPolicy } from "./supervisor-journal";
+export interface SupervisorLoopRunInput {
+    readonly projectRoot: string;
+    readonly maxTasks?: number;
+    readonly concurrency?: number;
+    readonly selectionPolicy?: SupervisorSelectionPolicy;
+    readonly candidateTaskIds?: Iterable<string>;
+    readonly excludeTaskIds?: Iterable<string>;
+    readonly dryRun?: boolean;
+    readonly model?: string | null;
+    readonly force?: boolean;
+    readonly timeoutMs?: number;
+}
+export interface SupervisorLoopUnblockInput {
+    readonly projectRoot: string;
+    readonly taskId?: string | null;
+    readonly dryRun?: boolean;
+    readonly timeoutMs?: number;
+}
+export interface SupervisorLoopResult {
+    readonly ok: boolean;
+    readonly dryRun: boolean;
+    readonly plannedOrder: readonly string[];
+    readonly events: readonly SupervisorEvent[];
+    readonly projection: SupervisorProjection;
+}
+export interface SupervisorLoopService {
+    readonly runLoop: (input: SupervisorLoopRunInput) => Promise<SupervisorLoopResult>;
+    readonly unblock: (input: SupervisorLoopUnblockInput) => Promise<SupervisorLoopResult>;
+}
+export declare const SUPERVISOR_LOOP_CAPABILITY_ID = "rig.supervisor.loop";
+export declare const SUPERVISOR_LOOP: CapabilityId<SupervisorLoopService>;

package/dist/src/supervisor-loop.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/supervisor-loop.ts
+var SUPERVISOR_LOOP_CAPABILITY_ID = "rig.supervisor.loop";
+var SUPERVISOR_LOOP = makeCapabilityId(SUPERVISOR_LOOP_CAPABILITY_ID);
+export {
+  SUPERVISOR_LOOP_CAPABILITY_ID,
+  SUPERVISOR_LOOP
+};

package/dist/src/task-artifacts.d.ts

@@ -0,0 +1,53 @@
+import type { CapabilityId } from "./capability-id";
+import type { TaskArtifactReadResult } from "./task-data";
+export type TaskArtifactRef = {
+    readonly projectRoot: string;
+    readonly taskId?: string;
+};
+export type TaskArtifactListEntry = {
+    readonly path: string;
+    readonly sizeBytes: number;
+    readonly kind: "file" | "directory" | "other";
+    readonly modifiedAt?: string | null;
+};
+export type TaskArtifactWriteInput = TaskArtifactRef & {
+    readonly filename: string;
+    readonly content: string;
+};
+export type TaskArtifactReadInput = TaskArtifactRef & {
+    readonly filename: string;
+    readonly maxBytes?: number;
+};
+export type TaskArtifactWriteResult = {
+    readonly path: string;
+    readonly sizeBytes: number;
+};
+export type TaskDecisionAppendInput = TaskArtifactRef & {
+    readonly text: string;
+    readonly timestamp?: string;
+};
+export type TaskDecisionAppendResult = {
+    readonly taskId: string;
+    readonly path: string;
+    readonly message: string;
+};
+export type TaskCompletionArtifactsPrepareInput = TaskArtifactRef & {
+    readonly changedFiles: readonly string[];
+    readonly completedAt?: string;
+};
+export type TaskCompletionArtifactsPrepareResult = {
+    readonly taskId: string;
+    readonly artifactDir: string;
+    readonly message: string;
+};
+/** Task artifact directory/list/read/write vocabulary. */
+export interface TaskArtifactsService {
+    artifactDir(input: TaskArtifactRef): string;
+    listArtifacts(input: TaskArtifactRef): Promise<readonly TaskArtifactListEntry[]>;
+    readArtifact(input: TaskArtifactReadInput): Promise<TaskArtifactReadResult>;
+    writeArtifact(input: TaskArtifactWriteInput): Promise<TaskArtifactWriteResult>;
+    appendDecision(input: TaskDecisionAppendInput): Promise<TaskDecisionAppendResult>;
+    prepareCompletionArtifacts(input: TaskCompletionArtifactsPrepareInput): Promise<TaskCompletionArtifactsPrepareResult>;
+}
+export declare const TASK_ARTIFACTS_CAPABILITY_ID = "task-state.artifacts";
+export declare const TASK_ARTIFACTS: CapabilityId<TaskArtifactsService>;

package/dist/src/task-artifacts.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/task-artifacts.ts
+var TASK_ARTIFACTS_CAPABILITY_ID = "task-state.artifacts";
+var TASK_ARTIFACTS = makeCapabilityId(TASK_ARTIFACTS_CAPABILITY_ID);
+export {
+  TASK_ARTIFACTS_CAPABILITY_ID,
+  TASK_ARTIFACTS
+};

package/dist/src/task-config.d.ts

@@ -0,0 +1,22 @@
+/**
+ * task-config.ts - floor-neutral local task config entry vocabulary.
+ *
+ * The shape is shared by task-state/task-io compatibility paths, but read,
+ * write, normalization, and source materialization policy are owned by plugins.
+ */
+import type { TaskBrowserConfig } from "./browser";
+export type TaskConfigEntry = {
+    title?: string;
+    status?: string;
+    role?: string;
+    description?: string;
+    acceptance_criteria?: string;
+    scope?: string[];
+    validation?: string[];
+    browser?: TaskBrowserConfig;
+    repo_pins?: Record<string, string>;
+    criticality?: "core" | "high" | "normal";
+    queue_weight?: number;
+    creates_repo?: boolean;
+    auto_synced?: boolean;
+};

package/dist/src/task-config.js

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

package/dist/src/task-context-renderer.d.ts

@@ -0,0 +1,29 @@
+import type { CapabilityId } from "./capability-id";
+import type { RuntimeInstructionProvider } from "./provider-instructions";
+import type { RigTask, TaskRecord } from "./task-source";
+export type TaskContextRenderInput = {
+    readonly projectRoot: string;
+    readonly taskId?: string;
+    readonly task?: RigTask | TaskRecord | null;
+    readonly provider?: RuntimeInstructionProvider;
+};
+export type TaskScopeRenderInput = TaskContextRenderInput & {
+    readonly expandFiles?: boolean;
+};
+export type TaskPromptContextSection = {
+    readonly title: string;
+    readonly content: string;
+};
+export type TaskPromptContext = {
+    readonly taskId: string | null;
+    readonly sections: readonly TaskPromptContextSection[];
+};
+/** Provider/prompt-owned task info, scope, and dependency rendering vocabulary. */
+export interface TaskContextRendererService {
+    renderTaskInfo(input: TaskContextRenderInput): Promise<TaskPromptContextSection>;
+    renderTaskScope(input: TaskScopeRenderInput): Promise<TaskPromptContextSection>;
+    renderTaskDependencies(input: TaskContextRenderInput): Promise<TaskPromptContextSection>;
+    renderPromptContext(input: TaskContextRenderInput): Promise<TaskPromptContext>;
+}
+export declare const TASK_CONTEXT_RENDERER_CAPABILITY_ID = "provider.task-context-renderer";
+export declare const TASK_CONTEXT_RENDERER: CapabilityId<TaskContextRendererService>;

package/dist/src/task-context-renderer.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/task-context-renderer.ts
+var TASK_CONTEXT_RENDERER_CAPABILITY_ID = "provider.task-context-renderer";
+var TASK_CONTEXT_RENDERER = makeCapabilityId(TASK_CONTEXT_RENDERER_CAPABILITY_ID);
+export {
+  TASK_CONTEXT_RENDERER_CAPABILITY_ID,
+  TASK_CONTEXT_RENDERER
+};