@h-rig/contracts 0.0.6-alpha.16 → 0.0.6-alpha.161

package/dist/src/plugin.js

@@ -1,7 +1,230 @@
 // @bun
 // packages/contracts/src/plugin.ts
+import { Schema as Schema4 } from "effect";
+
+// packages/contracts/src/kernel.ts
+import { Schema as Schema3 } from "effect";
+
+// packages/contracts/src/baseSchemas.ts
 import { Schema } from "effect";
-var ValidatorCategory = Schema.Literals([
+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/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/stage.ts
+import { Schema as Schema2 } from "effect";
+var StageKind = Schema2.Literals(["transform", "gate", "observe"]);
+var StageId = TrimmedNonEmptyString.pipe(Schema2.brand("StageId"));
+var StageContext = Schema2.Struct({
+  runId: RunId,
+  taskId: Schema2.optional(Schema2.NullOr(TaskId)),
+  state: Schema2.Unknown,
+  metadata: Schema2.optional(Schema2.Record(Schema2.String, Schema2.Unknown))
+});
+var StageDescriptor = Schema2.Struct({
+  id: StageId,
+  kind: StageKind,
+  before: Schema2.optional(Schema2.Array(StageId)),
+  after: Schema2.optional(Schema2.Array(StageId)),
+  priority: Schema2.Number.pipe(Schema2.withDecodingDefault(() => 0)),
+  protected: Schema2.Boolean.pipe(Schema2.withDecodingDefault(() => false))
+});
+var Stage = StageDescriptor;
+var StageContinueResult = Schema2.Struct({
+  kind: Schema2.Literal("continue"),
+  ctx: StageContext
+});
+var StageAllowResult = Schema2.Struct({
+  kind: Schema2.Literal("allow")
+});
+var StageBlockResult = Schema2.Struct({
+  kind: Schema2.Literal("block"),
+  reason: TrimmedNonEmptyString
+});
+var StageResult = Schema2.Union([
+  StageContinueResult,
+  StageAllowResult,
+  StageBlockResult
+]);
+var StageWrapperDescriptor = Schema2.Struct({
+  id: TrimmedNonEmptyString,
+  priority: Schema2.Number.pipe(Schema2.withDecodingDefault(() => 0))
+});
+var StageMutationOp = Schema2.Literals(["insert", "remove", "replace", "wrap", "reorder"]);
+var InsertStageMutation = Schema2.Struct({
+  op: Schema2.Literal("insert"),
+  stage: StageDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var RemoveStageMutation = Schema2.Struct({
+  op: Schema2.Literal("remove"),
+  id: StageId,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var ReplaceStageMutation = Schema2.Struct({
+  op: Schema2.Literal("replace"),
+  id: StageId,
+  stage: StageDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var WrapStageMutation = Schema2.Struct({
+  op: Schema2.Literal("wrap"),
+  id: StageId,
+  around: StageWrapperDescriptor,
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var ReorderStageMutation = Schema2.Struct({
+  op: Schema2.Literal("reorder"),
+  id: StageId,
+  before: Schema2.optional(Schema2.Array(StageId)),
+  after: Schema2.optional(Schema2.Array(StageId)),
+  contributedBy: Schema2.optional(TrimmedNonEmptyString)
+});
+var StageMutation = Schema2.Union([
+  InsertStageMutation,
+  RemoveStageMutation,
+  ReplaceStageMutation,
+  WrapStageMutation,
+  ReorderStageMutation
+]);
+var ResolutionGrantUse = Schema2.Struct({
+  kind: Schema2.Literal("kernel-replacement"),
+  target: TrimmedNonEmptyString,
+  pluginId: TrimmedNonEmptyString
+});
+var ResolutionRecordEntry = Schema2.Struct({
+  stageId: StageId,
+  contributedBy: TrimmedNonEmptyString,
+  removedBy: Schema2.optional(TrimmedNonEmptyString),
+  replacedBy: Schema2.optional(TrimmedNonEmptyString),
+  wrappedBy: Schema2.optional(Schema2.Array(TrimmedNonEmptyString)),
+  droppedAnchors: Schema2.optional(Schema2.Array(StageId)),
+  isProtected: Schema2.Boolean
+});
+var ResolvedPipeline = Schema2.Struct({
+  runId: Schema2.optional(RunId),
+  order: Schema2.Array(StageId),
+  record: Schema2.Array(ResolutionRecordEntry),
+  cycles: Schema2.Array(Schema2.Array(StageId)),
+  grantUses: Schema2.optional(Schema2.Array(ResolutionGrantUse)),
+  resolvedAt: Schema2.optional(IsoDateTime)
+});
+var StageRunOutcome = Schema2.Struct({
+  stageId: StageId,
+  result: StageResult,
+  startedAt: IsoDateTime,
+  finishedAt: IsoDateTime
+});
+
+// packages/contracts/src/kernel.ts
+var CapabilityTag = Schema3.Literals([
+  "kernel",
+  "journal",
+  "stage-runner",
+  "transport",
+  "loader-policy"
+]);
+var CapabilityProviderRef = Schema3.Struct({
+  capability: CapabilityTag,
+  pluginId: TrimmedNonEmptyString
+});
+var CapabilityReplacement = Schema3.Struct({
+  capability: CapabilityTag,
+  providerPluginId: TrimmedNonEmptyString
+});
+var CapabilityReplacementSpec = Schema3.Union([
+  CapabilityReplacement,
+  TrimmedNonEmptyString
+]);
+var KernelReplacementGrant = Schema3.Struct({
+  pluginId: TrimmedNonEmptyString,
+  grantedBy: Schema3.optional(TrimmedNonEmptyString),
+  reason: Schema3.optional(Schema3.String)
+});
+var CapabilityGrants = Schema3.Struct({
+  capabilityPrecedence: Schema3.optional(Schema3.Record(Schema3.String, Schema3.Array(TrimmedNonEmptyString))),
+  kernelReplacementGrants: Schema3.optional(Schema3.Array(KernelReplacementGrant))
+});
+var KernelBootErrorCode = Schema3.Literals([
+  "BootIncoherent",
+  "AmbiguousCapability",
+  "MissingCapability",
+  "KernelReplacementDenied",
+  "PipelineUnresolvable"
+]);
+var KernelBootError = Schema3.Struct({
+  code: KernelBootErrorCode,
+  message: TrimmedNonEmptyString,
+  capability: Schema3.optional(CapabilityTag),
+  stageId: Schema3.optional(TrimmedNonEmptyString),
+  pluginIds: Schema3.optional(Schema3.Array(TrimmedNonEmptyString))
+});
+var CapabilityResolutionStatus = Schema3.Literals(["resolved", "ambiguous", "missing", "replaced"]);
+var CapabilityResolutionRecord = Schema3.Struct({
+  capability: CapabilityTag,
+  status: CapabilityResolutionStatus,
+  selectedPluginId: Schema3.NullOr(TrimmedNonEmptyString),
+  candidatePluginIds: Schema3.Array(TrimmedNonEmptyString),
+  precedenceUsed: Schema3.Boolean,
+  replacementUsed: Schema3.optional(CapabilityReplacement),
+  error: Schema3.optional(Schema3.String)
+});
+var KernelResolutionRecord = Schema3.Struct({
+  resolvedAt: IsoDateTime,
+  capabilities: Schema3.Array(CapabilityResolutionRecord),
+  pipeline: Schema3.optional(ResolvedPipeline)
+});
+var BootResultDescriptor = Schema3.Struct({
+  kernelPluginId: TrimmedNonEmptyString,
+  pluginIds: Schema3.Array(TrimmedNonEmptyString),
+  resolution: KernelResolutionRecord
+});
+var JournalEvent = Schema3.Struct({
+  type: TrimmedNonEmptyString,
+  runId: Schema3.optional(RunId),
+  at: IsoDateTime,
+  payload: Schema3.Unknown
+});
+var PLACEMENT_RUN_TRANSPORT = makeCapabilityId("transport.placement-run");
+
+// packages/contracts/src/plugin.ts
+var ValidatorCategory = Schema4.Literals([
   "boundary",
   "contract",
   "integration",
@@ -9,12 +232,12 @@ var ValidatorCategory = Schema.Literals([
   "external",
   "custom"
 ]);
-var ValidatorRegistration = Schema.Struct({
-  id: Schema.String,
+var ValidatorRegistration = Schema4.Struct({
+  id: Schema4.String,
   category: ValidatorCategory,
-  description: Schema.optional(Schema.String)
+  description: Schema4.optional(Schema4.String)
 });
-var HookEvent = Schema.Literals([
+var AgentSessionHookEvent = Schema4.Literals([
   "PreToolUse",
   "PostToolUse",
   "UserPromptSubmit",
@@ -22,67 +245,119 @@ var HookEvent = Schema.Literals([
   "SessionStart",
   "SessionEnd"
 ]);
-var HookMatcher = Schema.Union([
-  Schema.Struct({ kind: Schema.Literal("all") }),
-  Schema.Struct({ kind: Schema.Literal("tool"), name: Schema.String }),
-  Schema.Struct({ kind: Schema.Literal("glob"), pattern: Schema.String })
+var HookEvent = AgentSessionHookEvent;
+var HookMatcher = Schema4.Union([
+  Schema4.Struct({ kind: Schema4.Literal("all") }),
+  Schema4.Struct({ kind: Schema4.Literal("tool"), name: Schema4.String }),
+  Schema4.Struct({ kind: Schema4.Literal("glob"), pattern: Schema4.String })
 ]);
-var HookRegistration = Schema.Struct({
-  id: Schema.String,
-  event: HookEvent,
+var HookRegistration = Schema4.Struct({
+  id: Schema4.String,
+  event: AgentSessionHookEvent,
   matcher: HookMatcher,
-  command: Schema.optional(Schema.String),
-  description: Schema.optional(Schema.String)
-});
-var SkillRegistration = Schema.Struct({
-  id: Schema.String,
-  path: Schema.String,
-  description: Schema.optional(Schema.String)
-});
-var RepoSourceRegistration = Schema.Struct({
-  id: Schema.String,
-  url: Schema.String,
-  defaultPath: Schema.optional(Schema.String),
-  description: Schema.optional(Schema.String),
-  defaultBranch: Schema.optional(Schema.String),
-  remoteEnvVar: Schema.optional(Schema.String),
-  checkoutEnvVar: Schema.optional(Schema.String)
-});
-var AgentRoleRegistration = Schema.Struct({
-  id: Schema.String,
-  defaultModel: Schema.optional(Schema.String),
-  description: Schema.optional(Schema.String)
-});
-var TaskFieldExtension = Schema.Struct({
-  id: Schema.String,
-  fieldName: Schema.String,
-  schemaJson: Schema.String
-});
-var TaskSourceKind = Schema.String;
-var TaskSourceRegistration = Schema.Struct({
-  id: Schema.String,
-  kind: Schema.String,
-  description: Schema.optional(Schema.String)
-});
-var CliCommandRegistration = Schema.Struct({
-  id: Schema.String,
-  command: Schema.String,
-  description: Schema.optional(Schema.String)
-});
-var PluginContributes = Schema.Struct({
-  validators: Schema.optional(Schema.Array(ValidatorRegistration)),
-  hooks: Schema.optional(Schema.Array(HookRegistration)),
-  skills: Schema.optional(Schema.Array(SkillRegistration)),
-  repoSources: Schema.optional(Schema.Array(RepoSourceRegistration)),
-  agentRoles: Schema.optional(Schema.Array(AgentRoleRegistration)),
-  taskFieldSchemas: Schema.optional(Schema.Array(TaskFieldExtension)),
-  taskSources: Schema.optional(Schema.Array(TaskSourceRegistration)),
-  cliCommands: Schema.optional(Schema.Array(CliCommandRegistration))
-});
-var RigPlugin = Schema.Struct({
-  name: Schema.String,
-  version: Schema.String,
-  contributes: Schema.optional(PluginContributes)
+  command: Schema4.optional(Schema4.String),
+  description: Schema4.optional(Schema4.String)
+});
+var SkillRegistration = Schema4.Struct({
+  id: Schema4.String,
+  path: Schema4.String,
+  description: Schema4.optional(Schema4.String)
+});
+var RepoSourceRegistration = Schema4.Struct({
+  id: Schema4.String,
+  url: Schema4.String,
+  defaultPath: Schema4.optional(Schema4.String),
+  description: Schema4.optional(Schema4.String),
+  defaultBranch: Schema4.optional(Schema4.String),
+  remoteEnvVar: Schema4.optional(Schema4.String),
+  checkoutEnvVar: Schema4.optional(Schema4.String)
+});
+var AgentRoleRegistration = Schema4.Struct({
+  id: Schema4.String,
+  defaultModel: Schema4.optional(Schema4.String),
+  description: Schema4.optional(Schema4.String)
+});
+var TaskFieldExtension = Schema4.Struct({
+  id: Schema4.String,
+  fieldName: Schema4.String,
+  schemaJson: Schema4.String
+});
+var TaskSourceKind = Schema4.String;
+var TaskSourceRegistration = Schema4.Struct({
+  id: Schema4.String,
+  kind: Schema4.String,
+  description: Schema4.optional(Schema4.String)
+});
+var CliCommandRegistration = Schema4.Struct({
+  id: Schema4.String,
+  family: Schema4.optional(Schema4.String),
+  command: Schema4.optional(Schema4.String),
+  description: Schema4.optional(Schema4.String),
+  usage: Schema4.optional(Schema4.String),
+  aliases: Schema4.optional(Schema4.Array(Schema4.String)),
+  projectRequired: Schema4.optional(Schema4.Boolean),
+  rootDefault: Schema4.optional(Schema4.Boolean),
+  productRoot: Schema4.optional(Schema4.Boolean),
+  subcommands: Schema4.optional(Schema4.Array(Schema4.String))
+});
+var CapabilityRunSchema = Schema4.declare((u) => typeof u === "function", { identifier: "CapabilityRun" });
+var ProductCapabilityRegistration = Schema4.Struct({
+  id: Schema4.String,
+  title: Schema4.String,
+  description: Schema4.optional(Schema4.String),
+  commandId: Schema4.optional(Schema4.String),
+  panelId: Schema4.optional(Schema4.String),
+  run: Schema4.optional(CapabilityRunSchema)
+});
+var PanelRegistration = Schema4.Struct({
+  id: Schema4.String,
+  slot: Schema4.String,
+  title: Schema4.String,
+  capabilityId: Schema4.optional(Schema4.String),
+  badge: Schema4.optional(Schema4.String),
+  disabled: Schema4.optional(Schema4.Boolean),
+  description: Schema4.optional(Schema4.String)
+});
+var BlockerClassifierRegistration = Schema4.Struct({
+  id: Schema4.String,
+  description: Schema4.optional(Schema4.String),
+  priority: Schema4.optional(Schema4.Number)
+});
+var SessionExtensionRegistration = Schema4.Struct({
+  id: Schema4.String,
+  description: Schema4.optional(Schema4.String)
+});
+var SeedEntrypointRegistration = Schema4.Struct({
+  id: Schema4.String,
+  description: Schema4.optional(Schema4.String),
+  basename: Schema4.optional(Schema4.String),
+  workerArg: Schema4.optional(Schema4.String),
+  insidePty: Schema4.optional(Schema4.Boolean)
+});
+var PluginContributes = Schema4.Struct({
+  validators: Schema4.optional(Schema4.Array(ValidatorRegistration)),
+  hooks: Schema4.optional(Schema4.Array(HookRegistration)),
+  skills: Schema4.optional(Schema4.Array(SkillRegistration)),
+  repoSources: Schema4.optional(Schema4.Array(RepoSourceRegistration)),
+  agentRoles: Schema4.optional(Schema4.Array(AgentRoleRegistration)),
+  taskFieldSchemas: Schema4.optional(Schema4.Array(TaskFieldExtension)),
+  taskSources: Schema4.optional(Schema4.Array(TaskSourceRegistration)),
+  cliCommands: Schema4.optional(Schema4.Array(CliCommandRegistration)),
+  stages: Schema4.optional(Schema4.Array(Stage)),
+  stageMutations: Schema4.optional(Schema4.Array(StageMutation)),
+  capabilities: Schema4.optional(Schema4.Array(ProductCapabilityRegistration)),
+  panels: Schema4.optional(Schema4.Array(PanelRegistration)),
+  blockerClassifiers: Schema4.optional(Schema4.Array(BlockerClassifierRegistration)),
+  sessionExtensions: Schema4.optional(Schema4.Array(SessionExtensionRegistration)),
+  seedEntrypoints: Schema4.optional(Schema4.Array(SeedEntrypointRegistration))
+});
+var RigPlugin = Schema4.Struct({
+  name: Schema4.String,
+  version: Schema4.String,
+  provides: Schema4.optional(Schema4.Array(CapabilityTag)),
+  requires: Schema4.optional(Schema4.Array(CapabilityTag)),
+  replaces: Schema4.optional(Schema4.Array(CapabilityReplacementSpec)),
+  contributes: Schema4.optional(PluginContributes)
 });
 export {
   ValidatorRegistration,
@@ -91,12 +366,19 @@ export {
   TaskSourceKind,
   TaskFieldExtension,
   SkillRegistration,
+  SessionExtensionRegistration,
+  SeedEntrypointRegistration,
   RigPlugin,
   RepoSourceRegistration,
+  ProductCapabilityRegistration,
   PluginContributes,
+  PanelRegistration,
   HookRegistration,
   HookMatcher,
   HookEvent,
   CliCommandRegistration,
+  CapabilityRunSchema,
+  BlockerClassifierRegistration,
+  AgentSessionHookEvent,
   AgentRoleRegistration
 };

package/dist/src/policy.d.ts

@@ -0,0 +1,16 @@
+import { Schema } from "effect";
+export declare const PolicyDecision: Schema.Literals<readonly ["allow", "warn", "block"]>;
+export type PolicyDecision = typeof PolicyDecision.Type;
+export declare const PolicyMode: Schema.Literals<readonly ["off", "observe", "enforce"]>;
+export type PolicyMode = typeof PolicyMode.Type;
+export declare const PolicyDecisionSummary: Schema.Struct<{
+    readonly id: Schema.Trim;
+    readonly runId: Schema.brand<Schema.Trim, "RunId">;
+    readonly actionId: Schema.NullOr<Schema.brand<Schema.Trim, "ActionId">>;
+    readonly decision: Schema.Literals<readonly ["allow", "warn", "block"]>;
+    readonly mode: Schema.Literals<readonly ["off", "observe", "enforce"]>;
+    readonly matchedRules: Schema.$Array<Schema.Trim>;
+    readonly reason: Schema.String;
+    readonly createdAt: Schema.String;
+}>;
+export type PolicyDecisionSummary = typeof PolicyDecisionSummary.Type;

package/dist/src/policy.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/project.d.ts

@@ -0,0 +1,71 @@
+import { Schema } from "effect";
+export declare const ProjectSearchEntriesInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly query: Schema.Trim;
+    readonly limit: Schema.Int;
+}>;
+export type ProjectSearchEntriesInput = typeof ProjectSearchEntriesInput.Type;
+export declare const ProjectEntry: Schema.Struct<{
+    readonly path: Schema.Trim;
+    readonly kind: Schema.Literals<readonly ["file", "directory"]>;
+    readonly parentPath: Schema.optional<Schema.Trim>;
+}>;
+export type ProjectEntry = typeof ProjectEntry.Type;
+export declare const ProjectSearchEntriesResult: Schema.Struct<{
+    readonly entries: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.Trim;
+        readonly kind: Schema.Literals<readonly ["file", "directory"]>;
+        readonly parentPath: Schema.optional<Schema.Trim>;
+    }>>;
+    readonly truncated: Schema.Boolean;
+}>;
+export type ProjectSearchEntriesResult = typeof ProjectSearchEntriesResult.Type;
+export declare const ProjectListDirectoryInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly relativePath: Schema.Trim;
+    readonly limit: Schema.Int;
+}>;
+export type ProjectListDirectoryInput = typeof ProjectListDirectoryInput.Type;
+export declare const ProjectDirectoryEntry: Schema.Struct<{
+    readonly name: Schema.Trim;
+    readonly relativePath: Schema.Trim;
+    readonly kind: Schema.Literals<readonly ["file", "directory"]>;
+    readonly sizeBytes: Schema.optional<Schema.Int>;
+    readonly modifiedAt: Schema.optional<Schema.String>;
+}>;
+export type ProjectDirectoryEntry = typeof ProjectDirectoryEntry.Type;
+export declare const ProjectListDirectoryResult: Schema.Struct<{
+    readonly entries: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.Trim;
+        readonly relativePath: Schema.Trim;
+        readonly kind: Schema.Literals<readonly ["file", "directory"]>;
+        readonly sizeBytes: Schema.optional<Schema.Int>;
+        readonly modifiedAt: Schema.optional<Schema.String>;
+    }>>;
+    readonly truncated: Schema.Boolean;
+}>;
+export type ProjectListDirectoryResult = typeof ProjectListDirectoryResult.Type;
+export declare const ProjectWriteFileInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly relativePath: Schema.Trim;
+    readonly contents: Schema.String;
+}>;
+export type ProjectWriteFileInput = typeof ProjectWriteFileInput.Type;
+export declare const ProjectWriteFileResult: Schema.Struct<{
+    readonly relativePath: Schema.Trim;
+}>;
+export type ProjectWriteFileResult = typeof ProjectWriteFileResult.Type;
+export declare const ProjectReadFileInput: Schema.Struct<{
+    readonly cwd: Schema.Trim;
+    readonly relativePath: Schema.Trim;
+}>;
+export type ProjectReadFileInput = typeof ProjectReadFileInput.Type;
+export declare const ProjectReadFileResult: Schema.Struct<{
+    readonly relativePath: Schema.Trim;
+    readonly contents: Schema.String;
+    readonly truncated: Schema.Boolean;
+    readonly sizeBytes: Schema.Int;
+    readonly maxBytes: Schema.Int;
+}>;
+export type ProjectReadFileResult = typeof ProjectReadFileResult.Type;
+export declare const PROJECT_READ_FILE_MAX_BYTES_VALUE: number;

package/dist/src/project.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/prompt.d.ts

@@ -0,0 +1,29 @@
+/**
+ * prompt.ts — pure capability vocabulary for agent prompt assembly.
+ *
+ * Moved here from `@rig/prompt-plugin` (where it was defined locally): the FLOOR
+ * cannot resolve a capability whose id/input type only exist inside a plugin
+ * without importing the plugin. The plugin OWNS the impl
+ * (`readPriorPrProgressPromptSection`, lazy-loaded inside `run()`) and registers
+ * it under this id; consumers resolve it off the host. Types only here.
+ */
+import type { CapabilityId } from "./capability-id";
+/**
+ * Capability id: agent prompt assembly — the prior-progress section of what the
+ * agent is told for a re-dispatched task.
+ */
+export declare const PRIOR_PROGRESS_PROMPT_CAPABILITY_ID = "prompt.prior-progress";
+/** Pure input: which workspace + task to assemble the prior-progress section for. */
+export type PriorProgressPromptInput = {
+    readonly projectRoot: string;
+    readonly taskId: string;
+};
+/**
+ * The cohesive prompt-assembly operation: returns the prior-PR-progress prompt
+ * section, or null when there is no prior progress. Async (reads fs).
+ */
+export interface PriorProgressPromptService {
+    readPriorProgressSection(input: PriorProgressPromptInput): Promise<string | null>;
+}
+/** Typed capability id; string value is {@link PRIOR_PROGRESS_PROMPT_CAPABILITY_ID}. */
+export declare const PRIOR_PROGRESS_PROMPT: CapabilityId<PriorProgressPromptService>;

package/dist/src/prompt.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/prompt.ts
+var PRIOR_PROGRESS_PROMPT_CAPABILITY_ID = "prompt.prior-progress";
+var PRIOR_PROGRESS_PROMPT = makeCapabilityId(PRIOR_PROGRESS_PROMPT_CAPABILITY_ID);
+export {
+  PRIOR_PROGRESS_PROMPT_CAPABILITY_ID,
+  PRIOR_PROGRESS_PROMPT
+};

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

@@ -0,0 +1,21 @@
+/**
+ * Rig client–server protocol version.
+ *
+ * A single integer shared by the server (reported in the
+ * `GET /api/server/status` bootstrap payload as `protocolVersion`) and by
+ * clients that speak the HTTP/WS surface (the pi-rig bridge validates it at
+ * extension init and disables itself on mismatch instead of failing on a
+ * random later request).
+ *
+ * Bump rules:
+ * - Increment whenever a change to the server API surface would break an
+ *   older client (removed/renamed routes, changed payload shapes, changed
+ *   steering/event semantics).
+ * - Purely additive changes (new routes, new optional fields) do NOT require
+ *   a bump.
+ *
+ * History:
+ * - 1: first explicit version (2026-06). Servers older than this do not
+ *   report `protocolVersion` at all; clients treat the missing field as v0.
+ */
+export declare const RIG_PROTOCOL_VERSION = 1;

package/dist/src/protocol-version.js

@@ -0,0 +1,6 @@
+// @bun
+// packages/contracts/src/protocol-version.ts
+var RIG_PROTOCOL_VERSION = 1;
+export {
+  RIG_PROTOCOL_VERSION
+};

package/dist/src/provider-instructions.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Pure provider-instruction contract types.
+ *
+ * Neutral home for the agent-harness provider identity so the dumb runtime
+ * substrate (native/task-ops, hooks/inject-context) and the
+ * @rig/provider-plugin that owns the instruction text can both reference it
+ * without a substrate->plugin import cycle. Carries no behaviour and imports
+ * nothing — exactly like `memory.ts` / `lifecycle-capabilities.ts`.
+ *
+ * The plugin registers its executable `RuntimeInstructionService` impl under the
+ * typed id {@link RUNTIME_INSTRUCTION} (whose string value is
+ * {@link RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID}) via `*.provide`; the runtime
+ * resolves it by id from `pluginHost.listExecutableCapabilities()` via the
+ * `defineCapability` seam (`@rig/core/capability`), re-exported from the thin
+ * `@rig/runtime/control-plane/provider-instruction-port`.
+ */
+import type { CapabilityId } from "./capability-id";
+/** Capability id the provider plugin registers its instruction service under. */
+export declare const RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID = "provider.runtime-instructions";
+/** The agent harness adapter the runtime is currently wired to. */
+export type RuntimeInstructionProvider = "pi";
+/**
+ * The cohesive set of agent-harness instruction builders the runtime consumers
+ * depend on. This is pure capability VOCAB: the `@rig/provider-plugin` provides a
+ * concrete impl (statically checked against this interface via the typed
+ * capability seam), 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 RuntimeInstructionService {
+    normalizeProvider(value: string | undefined | null): RuntimeInstructionProvider;
+    buildTaskRunInstructionLines(provider: RuntimeInstructionProvider): string[];
+    buildRuntimeContextLines(provider: RuntimeInstructionProvider): string[];
+}
+/**
+ * The typed capability id the provider plugin provides and consumers require.
+ * Phantom-typed with `RuntimeInstructionService` so `resolve(host)` returns a
+ * `RuntimeInstructionService` with no cast leaking to callers. Its string value
+ * is {@link RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID}, so it indexes the same
+ * host entry.
+ */
+export declare const RUNTIME_INSTRUCTION: CapabilityId<RuntimeInstructionService>;