@h-rig/contracts 0.0.6-alpha.9 → 0.0.6-alpha.90

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/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/hook-kit'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
+ *                    (@rig/hook-kit's `extractToolFilePaths`)
+ * - `projectRoot`  — resolved project root (@rig/hook-kit's `resolveProjectRoot`)
+ * - `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/hook-kit's
+ * `block()` uses (the contract Claude Code's hook runner expects):
+ * - `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
+ * runtime channel: `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;

package/dist/src/plugin-hooks.js

@@ -0,0 +1,112 @@
+// @bun
+// packages/contracts/src/plugin-hooks.ts
+import { Schema as Schema2 } from "effect";
+
+// packages/contracts/src/plugin.ts
+import { Schema } from "effect";
+var ValidatorCategory = Schema.Literals([
+  "boundary",
+  "contract",
+  "integration",
+  "regression",
+  "external",
+  "custom"
+]);
+var ValidatorRegistration = Schema.Struct({
+  id: Schema.String,
+  category: ValidatorCategory,
+  description: Schema.optional(Schema.String)
+});
+var HookEvent = Schema.Literals([
+  "PreToolUse",
+  "PostToolUse",
+  "UserPromptSubmit",
+  "Stop",
+  "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 HookRegistration = Schema.Struct({
+  id: Schema.String,
+  event: HookEvent,
+  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)
+});
+
+// packages/contracts/src/plugin-hooks.ts
+var HookToolInput = Schema2.Record(Schema2.String, Schema2.Unknown);
+var HookContext = Schema2.Struct({
+  event: HookEvent,
+  toolName: Schema2.optional(Schema2.String),
+  toolInput: HookToolInput,
+  filePaths: Schema2.Array(Schema2.String),
+  projectRoot: Schema2.String,
+  taskId: Schema2.String
+});
+var HookDecision = Schema2.Literals(["allow", "block"]);
+var HookResult = Schema2.Struct({
+  decision: HookDecision,
+  reason: Schema2.optional(Schema2.String),
+  systemMessage: Schema2.optional(Schema2.String)
+});
+export {
+  HookToolInput,
+  HookResult,
+  HookDecision,
+  HookContext
+};

package/dist/src/plugin.d.ts

@@ -0,0 +1,230 @@
+import { Schema } from "effect";
+export declare const ValidatorCategory: Schema.Literals<readonly ["boundary", "contract", "integration", "regression", "external", "custom"]>;
+export type ValidatorCategory = typeof ValidatorCategory.Type;
+export declare const ValidatorRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly category: Schema.Literals<readonly ["boundary", "contract", "integration", "regression", "external", "custom"]>;
+    readonly description: Schema.optional<Schema.String>;
+}>;
+export type ValidatorRegistration = typeof ValidatorRegistration.Type;
+export declare const HookEvent: Schema.Literals<readonly ["PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop", "SessionStart", "SessionEnd"]>;
+export type HookEvent = typeof HookEvent.Type;
+export declare const HookMatcher: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"all">;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"tool">;
+    readonly name: Schema.String;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"glob">;
+    readonly pattern: Schema.String;
+}>]>;
+export type HookMatcher = typeof HookMatcher.Type;
+export declare const HookRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly event: Schema.Literals<readonly ["PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop", "SessionStart", "SessionEnd"]>;
+    readonly matcher: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"all">;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"tool">;
+        readonly name: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"glob">;
+        readonly pattern: Schema.String;
+    }>]>;
+    /**
+     * Shell command Claude Code invokes when this hook fires. Resolved as-is by
+     * Claude Code's hook runner. Use absolute paths or expand
+     * `$CLAUDE_PROJECT_DIR` for project-relative paths.
+     *
+     * Alternative: leave `command` unset and ship a typed implementation via
+     * definePlugin's runtime channel (`{ hooks: { [hookId]: fn } }`) — see
+     * `HookContext`/`HookResult`/`HookImplementation` in plugin-hooks.ts. The
+     * runtime materializes a shim command for typed hooks automatically. A hook
+     * may not have both a `command` and a typed implementation.
+     */
+    readonly command: Schema.optional<Schema.String>;
+    readonly description: Schema.optional<Schema.String>;
+}>;
+export type HookRegistration = typeof HookRegistration.Type;
+export declare const SkillRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly path: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+}>;
+export type SkillRegistration = typeof SkillRegistration.Type;
+export declare const RepoSourceRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly url: Schema.String;
+    readonly defaultPath: Schema.optional<Schema.String>;
+    readonly description: Schema.optional<Schema.String>;
+    readonly defaultBranch: Schema.optional<Schema.String>;
+    readonly remoteEnvVar: Schema.optional<Schema.String>;
+    readonly checkoutEnvVar: Schema.optional<Schema.String>;
+}>;
+export type RepoSourceRegistration = typeof RepoSourceRegistration.Type;
+export declare const AgentRoleRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly defaultModel: Schema.optional<Schema.String>;
+    readonly description: Schema.optional<Schema.String>;
+}>;
+export type AgentRoleRegistration = typeof AgentRoleRegistration.Type;
+export declare const TaskFieldExtension: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly fieldName: Schema.String;
+    readonly schemaJson: Schema.String;
+}>;
+export type TaskFieldExtension = typeof TaskFieldExtension.Type;
+export declare const TaskSourceKind: Schema.String;
+export type TaskSourceKind = string;
+export declare const TaskSourceRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly kind: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+}>;
+export type TaskSourceRegistration = typeof TaskSourceRegistration.Type;
+export declare const CliCommandRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly command: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+}>;
+export type CliCommandRegistration = typeof CliCommandRegistration.Type;
+export declare const PluginContributes: Schema.Struct<{
+    readonly validators: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly category: Schema.Literals<readonly ["boundary", "contract", "integration", "regression", "external", "custom"]>;
+        readonly description: Schema.optional<Schema.String>;
+    }>>>;
+    readonly hooks: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly event: Schema.Literals<readonly ["PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop", "SessionStart", "SessionEnd"]>;
+        readonly matcher: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"all">;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"tool">;
+            readonly name: Schema.String;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"glob">;
+            readonly pattern: Schema.String;
+        }>]>;
+        /**
+         * Shell command Claude Code invokes when this hook fires. Resolved as-is by
+         * Claude Code's hook runner. Use absolute paths or expand
+         * `$CLAUDE_PROJECT_DIR` for project-relative paths.
+         *
+         * Alternative: leave `command` unset and ship a typed implementation via
+         * definePlugin's runtime channel (`{ hooks: { [hookId]: fn } }`) — see
+         * `HookContext`/`HookResult`/`HookImplementation` in plugin-hooks.ts. The
+         * runtime materializes a shim command for typed hooks automatically. A hook
+         * may not have both a `command` and a typed implementation.
+         */
+        readonly command: Schema.optional<Schema.String>;
+        readonly description: Schema.optional<Schema.String>;
+    }>>>;
+    readonly skills: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly path: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+    }>>>;
+    readonly repoSources: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly url: Schema.String;
+        readonly defaultPath: Schema.optional<Schema.String>;
+        readonly description: Schema.optional<Schema.String>;
+        readonly defaultBranch: Schema.optional<Schema.String>;
+        readonly remoteEnvVar: Schema.optional<Schema.String>;
+        readonly checkoutEnvVar: Schema.optional<Schema.String>;
+    }>>>;
+    readonly agentRoles: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly defaultModel: Schema.optional<Schema.String>;
+        readonly description: Schema.optional<Schema.String>;
+    }>>>;
+    readonly taskFieldSchemas: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly fieldName: Schema.String;
+        readonly schemaJson: Schema.String;
+    }>>>;
+    readonly taskSources: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly kind: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+    }>>>;
+    readonly cliCommands: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly command: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+    }>>>;
+}>;
+export type PluginContributes = typeof PluginContributes.Type;
+export declare const RigPlugin: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly version: Schema.String;
+    readonly contributes: Schema.optional<Schema.Struct<{
+        readonly validators: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly category: Schema.Literals<readonly ["boundary", "contract", "integration", "regression", "external", "custom"]>;
+            readonly description: Schema.optional<Schema.String>;
+        }>>>;
+        readonly hooks: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly event: Schema.Literals<readonly ["PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop", "SessionStart", "SessionEnd"]>;
+            readonly matcher: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"all">;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"tool">;
+                readonly name: Schema.String;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"glob">;
+                readonly pattern: Schema.String;
+            }>]>;
+            /**
+             * Shell command Claude Code invokes when this hook fires. Resolved as-is by
+             * Claude Code's hook runner. Use absolute paths or expand
+             * `$CLAUDE_PROJECT_DIR` for project-relative paths.
+             *
+             * Alternative: leave `command` unset and ship a typed implementation via
+             * definePlugin's runtime channel (`{ hooks: { [hookId]: fn } }`) — see
+             * `HookContext`/`HookResult`/`HookImplementation` in plugin-hooks.ts. The
+             * runtime materializes a shim command for typed hooks automatically. A hook
+             * may not have both a `command` and a typed implementation.
+             */
+            readonly command: Schema.optional<Schema.String>;
+            readonly description: Schema.optional<Schema.String>;
+        }>>>;
+        readonly skills: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly path: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+        }>>>;
+        readonly repoSources: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly url: Schema.String;
+            readonly defaultPath: Schema.optional<Schema.String>;
+            readonly description: Schema.optional<Schema.String>;
+            readonly defaultBranch: Schema.optional<Schema.String>;
+            readonly remoteEnvVar: Schema.optional<Schema.String>;
+            readonly checkoutEnvVar: Schema.optional<Schema.String>;
+        }>>>;
+        readonly agentRoles: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly defaultModel: Schema.optional<Schema.String>;
+            readonly description: Schema.optional<Schema.String>;
+        }>>>;
+        readonly taskFieldSchemas: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly fieldName: Schema.String;
+            readonly schemaJson: Schema.String;
+        }>>>;
+        readonly taskSources: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly kind: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+        }>>>;
+        readonly cliCommands: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly command: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+        }>>>;
+    }>>;
+}>;
+export type RigPlugin = typeof RigPlugin.Type;

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/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/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
+};