@rigkit/sdk 0.2.1 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigkit/sdk",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "type": "module",
   "repository": {
     "type": "git",
@@ -23,8 +23,8 @@
     "@effect/platform": "0.96.1",
     "@effect/platform-bun": "0.89.0",
     "effect": "^3.21.2",
-    "@rigkit/engine": "0.2.1",
-    "@rigkit/runtime-client": "0.2.1"
+    "@rigkit/engine": "0.2.3",
+    "@rigkit/runtime-client": "0.2.3"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/cli.ts

@@ -4,6 +4,7 @@ import { serveRuntime } from "./runtime/server.ts";
 
 type ServeArgs = {
   projectId?: string;
+  runtimeFingerprint?: string;
   projectDir?: string;
   configPath?: string;
   statePath?: string;
@@ -37,6 +38,7 @@ if (missing.length > 0) {
 
 const runtime = await serveRuntime({
   projectId: options.projectId!,
+  runtimeFingerprint: options.runtimeFingerprint,
   projectDir: resolve(options.projectDir!),
   configPath: resolve(options.configPath!),
   statePath: options.statePath ? resolve(options.statePath) : undefined,
@@ -79,6 +81,9 @@ function parseServeArgs(args: string[]): ServeArgs {
       case "--project-id":
         parsed.projectId = readValue();
         break;
+      case "--runtime-fingerprint":
+        parsed.runtimeFingerprint = readValue();
+        break;
       case "--project-dir":
       case "--project":
         parsed.projectDir = readValue();

package/src/index.test.ts

@@ -16,7 +16,7 @@ import { defineHostCapabilities, defineHostCapability } from "./host.ts";
 
 describe("@rigkit/sdk package boundary", () => {
   test("exports authoring API and project runtime entrypoints", () => {
-    expect(RIGKIT_SDK_VERSION).toBe("0.2.1");
+    expect(RIGKIT_SDK_VERSION).toBe("0.2.3");
     expect(env).toBeTypeOf("function");
     expect(env.secret).toBeTypeOf("function");
     expect(defineConfig).toBeTypeOf("function");

package/src/index.ts

@@ -19,12 +19,10 @@ export {
   DEFAULT_IDLE_MS,
   RIGKIT_RUNTIME_VERSION,
   createRuntimeStateService,
-  HostCapabilityRequirementEffectSchema,
   HostCommandRequestEffectSchema,
   HostCommandRequestSchema,
   HostCommandResultEffectSchema,
   HostCommandResultSchema,
-  HostMethodRequirementEffectSchema,
   HostResponseEffectSchema,
   HostResponseSchema,
   OkResponseEffectSchema,

package/src/runtime/api.ts

@@ -3,8 +3,6 @@ import { runtimeControlApi } from "@rigkit/runtime-client";
 
 export {
   RuntimeControlHealthEffectSchema as RuntimeHealthEffectSchema,
-  RuntimeControlHostCapabilityRequirementEffectSchema as HostCapabilityRequirementEffectSchema,
-  RuntimeControlHostMethodRequirementEffectSchema as HostMethodRequirementEffectSchema,
   RuntimeControlMetadataEffectSchema as RuntimeMetadataEffectSchema,
   RuntimeControlOkResponseEffectSchema as OkResponseEffectSchema,
   RuntimeControlOperationCliEffectSchema as RuntimeOperationCliEffectSchema,

package/src/runtime/app.test.ts

@@ -111,6 +111,7 @@ describe("runtime HTTP app", () => {
     let closed: Promise<void> | undefined;
 
     try {
+      writeNoopConfig(root);
       await Effect.runPromise(Effect.scoped(
         Effect.flatMap(
           serveRuntimeEffect({
@@ -146,6 +147,7 @@ describe("runtime HTTP app", () => {
     const root = mkdtempSync(join(tmpdir(), "rigkit-runtime-shutdown-"));
 
     try {
+      writeNoopConfig(root);
       const server = await serveRuntime({
         projectId: "test-project",
         projectDir: root,
@@ -167,6 +169,26 @@ describe("runtime HTTP app", () => {
     }
   });
 
+  test("loads config before reporting runtime readiness", async () => {
+    const root = mkdtempSync(join(tmpdir(), "rigkit-runtime-startup-config-"));
+    const configPath = join(root, "rig.config.ts");
+    writeFileSync(configPath, "throw new Error('startup config failed');\n");
+
+    try {
+      await expect(serveRuntime({
+        projectId: "test-project",
+        projectDir: root,
+        configPath,
+        handlePath: join(root, "runtime.json"),
+        tokenPath: join(root, "runtime.token"),
+        token: "test-token",
+        idleMs: 60_000,
+      })).rejects.toThrow("startup config failed");
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  });
+
   test("returns structured validation errors", async () => {
     const app = createRuntimeApp(testContext(), createRunStore());
 
@@ -215,11 +237,10 @@ describe("runtime HTTP app", () => {
       scheme: "bearer",
     });
     expect(body.components.schemas.RuntimeOperation.required).toContain("inputSchema");
-    expect(body.components.schemas.Workspace.required).toContain("data");
+    expect(body.components.schemas.Workspace.required).toContain("ctx");
     expect(body.components.schemas.OperationsManifest.required).toEqual([
-      "hostMethods",
-      "hostCapabilities",
       "operations",
+      "workspaceOperations",
     ]);
   });
 
@@ -255,7 +276,6 @@ describe("runtime HTTP app", () => {
           kind: "command",
           title: "SSH",
           description: "Get an SSH command",
-          requiredHostMethods: [{ id: "host.command.run", modes: ["interactive"] }],
           inputFields: [
             { kind: "string", name: "workflow", required: false },
             { kind: "string", name: "workspaceOrVmId", position: 0, required: true },
@@ -277,9 +297,6 @@ describe("runtime HTTP app", () => {
           source: "config",
           title: "Open",
           description: "Open a workspace",
-          createsWorkspace: false,
-          requiredHostMethods: [{ id: "host.command.run", modes: ["interactive"] }],
-          requiredHostCapabilities: [{ id: "cmux.open", schemaHash: "sha256:cmux-open-schema" }],
           inputFields: [
             {
               kind: "workspace",
@@ -297,33 +314,47 @@ describe("runtime HTTP app", () => {
             },
           ],
         },
+        {
+          workflow: "",
+          id: "create",
+          source: "core",
+          kind: "command",
+          createsWorkspace: true,
+          inputFields: [{ kind: "string", name: "name", required: true }],
+        },
+      ],
+      listRuntimeWorkspaceOperations: () => [
         {
           workflow: "test",
-          id: "fork",
+          id: "remove",
+          source: "core",
+          kind: "workspace-action",
+          title: "Remove",
+          description: "Remove a workspace",
+          inputFields: [],
+        },
+        {
+          workflow: "test",
+          id: "open-cmux",
           source: "config",
-          createsWorkspace: true,
+          kind: "workspace-action",
+          title: "Open cmux",
+          description: "Open a workspace in cmux",
           inputFields: [],
         },
       ],
     } as any);
 
     const operation = manifest.operations.find((item) => item.id === "open");
-    const forkOperation = manifest.operations.find((item) => item.id === "fork");
+    const createOperation = manifest.operations.find((item) => item.id === "create");
     const sshOperation = manifest.operations.find((item) => item.id === "ssh");
+    const cmuxOperation = manifest.workspaceOperations.find((item) => item.id === "open-cmux");
     const inputSchema = operation?.inputSchema as any;
     const sshInputSchema = sshOperation?.inputSchema as any;
 
     expect(operation?.source).toBe("config");
     expect(operation?.kind).toBe("workspace-action");
-    expect(operation?.requiredHostMethods).toEqual([
-      { id: "host.command.run", modes: ["interactive"] },
-    ]);
-    expect(operation?.requiredHostCapabilities).toEqual([
-      { id: "cmux.open", schemaHash: "sha256:cmux-open-schema" },
-    ]);
-    expect(manifest.hostCapabilities.optional).toEqual([
-      { id: "cmux.open", schemaHash: "sha256:cmux-open-schema" },
-    ]);
+    expect(cmuxOperation?.id).toBe("open-cmux");
     expect(operation?.cli?.positionals).toEqual([{ name: "workspace", index: 0 }]);
     expect(operation?.cli?.options).toEqual([
       { name: "rebuild", flag: "--rebuild", required: false, type: "boolean" },
@@ -339,9 +370,9 @@ describe("runtime HTTP app", () => {
       default: false,
       description: "Rebuild before opening",
     });
-    expect(forkOperation?.source).toBe("config");
-    expect(forkOperation?.createsWorkspace).toBe(true);
-    expect(manifest.operations.some((item) => item.id === "create")).toBe(false);
+    expect(createOperation?.source).toBe("core");
+    expect(createOperation?.createsWorkspace).toBe(true);
+    expect(manifest.workspaceOperations.map((item) => item.id)).toEqual(["remove", "open-cmux"]);
     expect(sshOperation?.cli?.options?.find((item) => item.name === "print")).toEqual({
       name: "print",
       flag: "--print",
@@ -425,8 +456,6 @@ describe("runtime HTTP app", () => {
 
       expect(ack?.operation).toEqual({
         id: "plan",
-        requiredHostCapabilities: [],
-        requiredHostMethods: [],
       });
       expect(messages.some((message) => message.type === "heartbeat.ack")).toBe(true);
       expect(messages.some((message) => message.type === "run.completed")).toBe(true);
@@ -435,21 +464,24 @@ describe("runtime HTTP app", () => {
     }
   });
 
-  test("exposes persisted workspace payload as workspace data", async () => {
-    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-runtime-workspace-data-"));
+  test("exposes persisted workspace payload as workspace context", async () => {
+    const projectDir = mkdtempSync(join(tmpdir(), "rigkit-runtime-workspace-ctx-"));
     const configPath = join(projectDir, "rig.config.ts");
     writeFileSync(
       configPath,
       `
         import { defineConfig, sequence } from "${import.meta.dir}/../../../engine/src/index.ts";
 
-        const root = sequence("workspace-data")
+        const root = sequence("workspace-ctx")
           .step("prepare", async () => ({ repoPath: "/workspace/repo" }))
-          .create(async ({ ctx, name }) => ({
-            name,
-            resourceId: "resource-" + name,
-            repoPath: ctx.repoPath,
-          }));
+          .workspace({
+            create: async ({ workflow, workspace }) => ({
+              name: workspace.name,
+              vmId: "vm-" + workspace.name,
+              repoPath: workflow.ctx.repoPath,
+            }),
+            remove: async () => {},
+          });
 
         export default defineConfig({
           providers: {},
@@ -459,7 +491,7 @@ describe("runtime HTTP app", () => {
     );
 
     const server = await serveRuntime({
-      projectId: "project-workspace-data-test",
+      projectId: "project-workspace-ctx-test",
       projectDir,
       configPath,
       statePath: join(projectDir, "state.sqlite"),
@@ -483,14 +515,13 @@ describe("runtime HTTP app", () => {
 
       const { workspaces } = await fetch(new URL("/workspaces", server.url), {
         headers: { authorization: `Bearer ${server.token}` },
-      }).then((response) => response.json() as Promise<{ workspaces: Array<{ data: Record<string, unknown>; metadata: Record<string, unknown> }> }>);
+      }).then((response) => response.json() as Promise<{ workspaces: Array<{ ctx: Record<string, unknown> }> }>);
 
-      expect(workspaces[0]?.data).toEqual({
+      expect(workspaces[0]?.ctx).toEqual({
         name: "demo",
-        resourceId: "resource-demo",
+        vmId: "vm-demo",
         repoPath: "/workspace/repo",
       });
-      expect(workspaces[0]?.metadata).toEqual(workspaces[0]?.data);
     } finally {
       server.stop();
     }
@@ -506,7 +537,10 @@ describe("runtime HTTP app", () => {
 
         const root = sequence("validation")
           .step("prepare", async () => ({ ok: true }))
-          .create(async ({ name }) => ({ name, resourceId: "resource-" + name }));
+          .workspace({
+            create: async ({ workspace }) => ({ name: workspace.name, vmId: "vm-" + workspace.name }),
+            remove: async () => {},
+          });
 
         export default defineConfig({
           providers: {},
@@ -552,46 +586,9 @@ describe("runtime HTTP app", () => {
     }
   });
 
-  test("fails run sessions when host hello lacks required methods or capabilities", async () => {
-    const { server, projectDir } = await serveRuntimeFixture("rigkit-runtime-required-host-", `
-      const root = sequence("required-host").operation("needs-host", {
-        requiredHostMethods: [{ id: "host.command.run", modes: ["capture"] }],
-        requiredHostCapabilities: [{ id: "cmux.open", schemaHash: "sha256:cmux-open-schema" }],
-        run: async () => await new Promise(() => {}),
-      });
-
-      export default defineConfig({
-        providers: {},
-        workflows: { root },
-      });
-    `);
-
-    try {
-      const started = await startRun(server, "needs-host");
-      const messages = await collectSessionMessages(
-        new URL(started.sessionUrl, server.url),
-        server.token,
-        {
-          done: (items) => items.some((item) => item.type === "run.failed"),
-        },
-      );
-      const failed = messages.find((message) => message.type === "run.failed");
-      const message = String(failed?.error?.message ?? "");
-
-      expect(failed?.error?.code).toBe("HOST_REQUEST_FAILED");
-      expect(message).toContain("host method host.command.run:capture");
-      expect(message).toContain("host capability cmux.open@sha256:cmux-open-schema");
-      expect(messages.some((item) => item.type === "hello.ack")).toBe(false);
-    } finally {
-      server.stop();
-      rmSync(projectDir, { recursive: true, force: true });
-    }
-  });
-
   test("bridges typed host capability requests over run sessions", async () => {
     const { server, projectDir } = await serveRuntimeFixture("rigkit-runtime-capability-", `
       const root = sequence("capability-test").operation("open", {
-        requiredHostCapabilities: [{ id: "cmux.open", schemaHash: "sha256:cmux-open-schema" }],
         run: async ({ local }) => await local.requestCapability("cmux.open", { name: "demo" }),
       });
 
@@ -637,7 +634,6 @@ describe("runtime HTTP app", () => {
   test("resolves host capability resource lifetimes from session close reports", async () => {
     const { server, projectDir } = await serveRuntimeFixture("rigkit-runtime-capability-close-", `
       const root = sequence("capability-close-test").operation("open", {
-        requiredHostCapabilities: [{ id: "cmux.open", schemaHash: "sha256:cmux-open-schema" }],
         run: async ({ local }) => {
           if (!local.requestCapabilitySession) throw new Error("requestCapabilitySession unavailable");
           const session = await local.requestCapabilitySession("cmux.open", { name: "demo" });
@@ -686,7 +682,6 @@ describe("runtime HTTP app", () => {
   test("keeps host-owned capability runs attached until the host cancels", async () => {
     const { server, projectDir } = await serveRuntimeFixture("rigkit-runtime-capability-attached-", `
       const root = sequence("capability-attached-test").operation("open", {
-        requiredHostCapabilities: [{ id: "cmux.open", schemaHash: "sha256:cmux-open-schema" }],
         run: async ({ local }) => {
           await local.requestCapability("cmux.open", { name: "demo" });
           await new Promise(() => {});
@@ -733,7 +728,6 @@ describe("runtime HTTP app", () => {
   test("turns host response errors into typed host request failures", async () => {
     const { server, projectDir } = await serveRuntimeFixture("rigkit-runtime-capability-error-", `
       const root = sequence("capability-error-test").operation("cmux-open", {
-        requiredHostCapabilities: [{ id: "cmux.open", schemaHash: "sha256:cmux-open-schema" }],
         run: async ({ local }) => await local.requestCapability("cmux.open", { name: "demo" }),
       });
 
@@ -806,6 +800,22 @@ describe("runtime HTTP app", () => {
   });
 });
 
+function writeNoopConfig(projectDir: string): void {
+  writeFileSync(
+    join(projectDir, "rig.config.ts"),
+    `
+      import { defineConfig, sequence } from "${import.meta.dir}/../../../engine/src/index.ts";
+
+      const root = sequence("noop").step("ready", async () => ({ ready: true }));
+
+      export default defineConfig({
+        providers: {},
+        workflows: { root },
+      });
+    `,
+  );
+}
+
 async function serveRuntimeFixture(prefix: string, configBody: string) {
   const projectDir = mkdtempSync(join(tmpdir(), prefix));
   const configPath = join(projectDir, "rig.config.ts");

package/src/runtime/cli.ts

@@ -4,6 +4,7 @@ import { serveRuntime } from "./server.ts";
 
 type ServeArgs = {
   projectId?: string;
+  runtimeFingerprint?: string;
   projectDir?: string;
   configPath?: string;
   statePath?: string;
@@ -37,6 +38,7 @@ if (missing.length > 0) {
 
 const runtime = await serveRuntime({
   projectId: options.projectId!,
+  runtimeFingerprint: options.runtimeFingerprint,
   projectDir: resolve(options.projectDir!),
   configPath: resolve(options.configPath!),
   statePath: options.statePath ? resolve(options.statePath) : undefined,
@@ -78,6 +80,9 @@ function parseServeArgs(args: string[]): ServeArgs {
       case "--project-id":
         parsed.projectId = readValue();
         break;
+      case "--runtime-fingerprint":
+        parsed.runtimeFingerprint = readValue();
+        break;
       case "--project-dir":
       case "--project":
         parsed.projectDir = readValue();

package/src/runtime/control.ts

@@ -9,6 +9,7 @@ import {
   type HostResponse,
   type RunOperationRequest,
   type RuntimeOperation,
+  type RuntimeOperationsManifest,
 } from "./protocol.ts";
 import {
   createRun,
@@ -34,6 +35,7 @@ export function runtimeHealth(context: RuntimeContext) {
   return {
     ok: true,
     projectId: context.projectId,
+    runtimeFingerprint: context.runtimeFingerprint,
     projectDir: context.projectDir,
     configPath: context.configPath,
     statePath: context.statePath,
@@ -86,10 +88,10 @@ export function runtimeRuns(store: RunStore) {
 export async function startRuntimeRun(state: RuntimeAppState, body: RunOperationRequest) {
   const engine = await loadEngine(state.context);
   const manifest = operationManifestFor(engine);
-  const operation = findRuntimeOperation(manifest.operations, body.operation);
-  if (!operation) throw new RuntimeControlHttpError(400, `Unknown operation ${body.operation}`);
+  const resolved = resolveRuntimeOperation(manifest, body.operation);
+  if (!resolved) throw new RuntimeControlHttpError(400, `Unknown operation ${body.operation}`);
 
-  const run = createRun(operation.id, body.input ?? {}, operation);
+  const run = createRun(resolved.runOperation, body.input ?? {}, resolved.operation);
   state.store.runs.set(run.id, run);
   runOperation(run, state.store, state.context);
 
@@ -143,16 +145,46 @@ export function runtimeControlErrorStatus(error: unknown): number {
   return 500;
 }
 
-function findRuntimeOperation(operations: RuntimeOperation[], requestedOperation: string): RuntimeOperation | undefined {
-  return operations.find((operation) =>
+function resolveRuntimeOperation(
+  manifest: RuntimeOperationsManifest,
+  requestedOperation: string,
+): { operation: RuntimeOperation; runOperation: string } | undefined {
+  const workspaceOperation = parseWorkspaceOperationId(requestedOperation);
+  if (workspaceOperation) {
+    const operation = manifest.workspaceOperations.find((item) => item.id === workspaceOperation.operation);
+    return operation ? { operation, runOperation: requestedOperation } : undefined;
+  }
+
+  const operation = manifest.operations.find((operation) =>
     operation.id === requestedOperation || operation.aliases?.includes(requestedOperation)
   );
+  return operation ? { operation, runOperation: operation.id } : undefined;
+}
+
+function parseWorkspaceOperationId(value: string): { workspace: string; operation: string } | undefined {
+  const slash = value.indexOf("/");
+  if (slash <= 0 || slash === value.length - 1) return undefined;
+  return {
+    workspace: value.slice(0, slash),
+    operation: value.slice(slash + 1),
+  };
 }
 
-function runtimeWorkspace(workspace: WorkspaceRecord): WorkspaceRecord & { data: WorkspaceRecord["metadata"] } {
+function runtimeWorkspace(workspace: WorkspaceRecord): {
+  id: string;
+  name: string;
+  workflow: string;
+  ctx: WorkspaceRecord["ctx"];
+  createdAt: string;
+  updatedAt: string;
+} {
   return {
-    ...workspace,
-    data: workspace.metadata,
+    id: workspace.id,
+    name: workspace.name,
+    workflow: workspace.workflow,
+    ctx: workspace.ctx,
+    createdAt: workspace.createdAt,
+    updatedAt: workspace.updatedAt,
   };
 }
 

package/src/runtime/index.ts

@@ -35,8 +35,6 @@ export {
   type RuntimeStateServiceOptions,
 } from "./state.ts";
 export {
-  HostCapabilityRequirementEffectSchema,
-  HostMethodRequirementEffectSchema,
   OkResponseEffectSchema,
   OperationsManifestEffectSchema,
   ProjectInfoEffectSchema,

package/src/runtime/operations.ts

@@ -100,6 +100,12 @@ export function operationsFor(engine: DevMachineEngine): RuntimeOperation[] {
   return engine.listRuntimeOperations().map((operation) => runtimeOperationForEngineOperation(engine, operation));
 }
 
+export function workspaceOperationsFor(engine: DevMachineEngine): RuntimeOperation[] {
+  return engine.listRuntimeWorkspaceOperations().map((operation) =>
+    runtimeOperationForEngineOperation(engine, operation)
+  );
+}
+
 function runtimeOperationForEngineOperation(engine: DevMachineEngine, operation: EngineOperationSummary): RuntimeOperation {
   const required = operation.inputFields
     .filter((field) => field.required ?? true)
@@ -116,14 +122,6 @@ function runtimeOperationForEngineOperation(engine: DevMachineEngine, operation:
     title: operation.title ?? titleize(operation.id),
     description: operation.description ?? "",
     createsWorkspace: operation.createsWorkspace,
-    requiredHostMethods: operation.requiredHostMethods?.map((method) => ({
-      id: method.id,
-      ...(method.modes?.length ? { modes: [...method.modes] } : {}),
-    })),
-    requiredHostCapabilities: operation.requiredHostCapabilities?.map((capability) => ({
-      id: capability.id,
-      ...(capability.schemaHash ? { schemaHash: capability.schemaHash } : {}),
-    })),
     cli: operation.cli ? cloneOperationCli(operation.cli) : cliForFields(operation.inputFields),
     inputSchema: objectSchema(properties, required),
   };
@@ -188,60 +186,13 @@ function cliForFields(fields: EngineOperationSummary["inputFields"]): NonNullabl
 
 export function operationManifestFor(engine: DevMachineEngine): RuntimeOperationsManifest {
   const operations = operationsFor(engine);
+  const workspaceOperations = workspaceOperationsFor(engine);
   return {
-    hostMethods: {
-      known: [
-        { id: "message.show" },
-        { id: "prompt.text" },
-        { id: "prompt.confirm" },
-        { id: "prompt.select" },
-        { id: "open.external" },
-        { id: "host.command.run", modes: ["capture", "interactive"] },
-      ],
-      requiredByOperations: Object.fromEntries(
-        operations
-          .filter((operation) => operation.requiredHostMethods?.length)
-          .map((operation) => [
-            operation.id,
-            operation.requiredHostMethods!.flatMap((method) =>
-              method.modes?.length
-                ? method.modes.map((mode) => `${method.id}:${mode}`)
-                : [method.id]
-            ),
-          ]),
-      ),
-    },
-    hostCapabilities: {
-      optional: dedupeHostCapabilities(
-        operations.flatMap((operation) => operation.requiredHostCapabilities ?? []),
-      ),
-      requiredByOperations: Object.fromEntries(
-        operations
-          .filter((operation) => operation.requiredHostCapabilities?.length)
-          .map((operation) => [operation.id, operation.requiredHostCapabilities!.map((capability) => capability.id)]),
-      ),
-    },
     operations,
+    workspaceOperations,
   };
 }
 
-function dedupeHostCapabilities(
-  capabilities: Array<{ id: string; schemaHash?: string }>,
-): Array<{ id: string; schemaHash?: string }> {
-  const seen = new Set<string>();
-  const deduped: Array<{ id: string; schemaHash?: string }> = [];
-  for (const capability of capabilities) {
-    const key = capability.schemaHash ? `${capability.id}\0${capability.schemaHash}` : capability.id;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    deduped.push({
-      id: capability.id,
-      ...(capability.schemaHash ? { schemaHash: capability.schemaHash } : {}),
-    });
-  }
-  return deduped;
-}
-
 function workflowJsonSchema(workflows: string[]): JsonSchema {
   return workflows.length > 0
     ? { type: "string", enum: workflows }

package/src/runtime/protocol.ts

@@ -2,7 +2,7 @@ import { Schema } from "effect";
 import type { WorkflowEvent } from "@rigkit/engine";
 
 export const RUNTIME_API_VERSION = 1;
-export const RUNTIME_PROTOCOL_HASH = "sha256:6dc28b06c95c98d310db445f1b19aef478cd828f11287467fe261483dfde4f81";
+export const RUNTIME_PROTOCOL_HASH = "sha256:ac8d4a503b56c15b333ea51f57ab1f6fca776bea93f498120b10ab601cc0960a";
 export const DEFAULT_IDLE_MS = 30 * 60 * 1000;
 
 export class RuntimeProtocolSchemaError extends Error {
@@ -147,16 +147,6 @@ export type RuntimeOperationCli = {
   options?: RuntimeOperationCliOption[];
 };
 
-export type RuntimeHostMethodRequirement = {
-  id: string;
-  modes?: string[];
-};
-
-export type RuntimeHostCapabilityRequirement = {
-  id: string;
-  schemaHash?: string;
-};
-
 export type RuntimeOperation = {
   id: string;
   aliases?: string[];
@@ -165,22 +155,13 @@ export type RuntimeOperation = {
   title: string;
   description: string;
   createsWorkspace?: boolean;
-  requiredHostMethods?: RuntimeHostMethodRequirement[];
-  requiredHostCapabilities?: RuntimeHostCapabilityRequirement[];
   cli?: RuntimeOperationCli;
   inputSchema: JsonSchema;
 };
 
 export type RuntimeOperationsManifest = {
-  hostMethods: {
-    known: RuntimeHostMethodRequirement[];
-    requiredByOperations: Record<string, string[]>;
-  };
-  hostCapabilities: {
-    optional: RuntimeHostCapabilityRequirement[];
-    requiredByOperations: Record<string, string[]>;
-  };
   operations: RuntimeOperation[];
+  workspaceOperations: RuntimeOperation[];
 };
 
 export function objectSchema(properties: Record<string, unknown>, required: string[] = []): JsonSchema {

package/src/runtime/server.ts

@@ -13,6 +13,7 @@ import { RIGKIT_RUNTIME_VERSION } from "./version.ts";
 import { runtimeJsonError, sessionRunIdFor } from "./app.ts";
 import { createRuntimeControlApiHandler } from "./api-handlers.ts";
 import type { RuntimeAppState } from "./control.ts";
+import { loadEngine } from "./operations.ts";
 import { runSessionSocketEffect } from "./sessions.ts";
 import { DEFAULT_IDLE_MS } from "./protocol.ts";
 import { createRunStore } from "./runs.ts";
@@ -60,6 +61,7 @@ export async function serveRuntime(options: ServeRuntimeOptions): Promise<Runtim
       options.handlePath,
       `${JSON.stringify({
         projectId: options.projectId,
+        runtimeFingerprint: options.runtimeFingerprint,
         projectDir,
         configPath,
         statePath,
@@ -76,6 +78,7 @@ export async function serveRuntime(options: ServeRuntimeOptions): Promise<Runtim
 
   const context: RuntimeContext = {
     projectId: options.projectId,
+    runtimeFingerprint: options.runtimeFingerprint,
     projectDir,
     configPath,
     statePath,
@@ -90,6 +93,8 @@ export async function serveRuntime(options: ServeRuntimeOptions): Promise<Runtim
     stop: () => stopServer(),
   };
   const state: RuntimeAppState = { context, store };
+  await loadEngine(context);
+
   const controlApi = createRuntimeControlApiHandler(context, store);
   const app = createRuntimeHttpApp(state, controlApi);
   const scope = Effect.runSync(Scope.make());

package/src/runtime/sessions.ts

@@ -81,19 +81,6 @@ function openRunSession(
       const message = parseSessionMessage(value);
       if (!message) return;
       if (message.type === "hello") {
-        const unsupported = unsupportedSessionRequirements(message, run.operationDefinition);
-        if (unsupported.length > 0) {
-          failRun(
-            run,
-            new RuntimeHostRequestError({
-              message: `Host does not support required ${unsupported.join(", ")}`,
-            }),
-            state.store,
-          );
-          acknowledged = true;
-          sendBacklog();
-          return;
-        }
         acknowledged = true;
         sendHelloAck(socket, run);
         sendBacklog();
@@ -160,53 +147,10 @@ function sendHelloAck(ws: RuntimeSessionTransport, run: { operation: string; ope
     },
     operation: {
       id: run.operation,
-      requiredHostCapabilities: run.operationDefinition?.requiredHostCapabilities ?? [],
-      requiredHostMethods: run.operationDefinition?.requiredHostMethods ?? [],
     },
   }));
 }
 
-function unsupportedSessionRequirements(message: SessionMessage, operation: RuntimeOperation | undefined): string[] {
-  const unsupported: string[] = [];
-  for (const requirement of operation?.requiredHostMethods ?? []) {
-    const hostMethod = sessionItems(message.hostMethods).find((item) => item.id === requirement.id);
-    if (!hostMethod || !supportsModes(hostMethod.modes, requirement.modes)) {
-      unsupported.push(`host method ${formatRequirement(requirement.id, requirement.modes)}`);
-    }
-  }
-  for (const requirement of operation?.requiredHostCapabilities ?? []) {
-    const capability = sessionItems(message.hostCapabilities).find((item) => item.id === requirement.id);
-    if (!capability || (requirement.schemaHash && capability.schemaHash !== requirement.schemaHash)) {
-      unsupported.push(requirement.schemaHash
-        ? `host capability ${requirement.id}@${requirement.schemaHash}`
-        : `host capability ${requirement.id}`);
-    }
-  }
-  return unsupported;
-}
-
-function sessionItems(value: unknown): Array<{ id: string; modes?: string[]; schemaHash?: string }> {
-  if (!Array.isArray(value)) return [];
-  return value.flatMap((item) => {
-    if (!isRecord(item) || typeof item.id !== "string") return [];
-    return [{
-      id: item.id,
-      modes: Array.isArray(item.modes) ? item.modes.filter((mode): mode is string => typeof mode === "string") : undefined,
-      schemaHash: typeof item.schemaHash === "string" ? item.schemaHash : undefined,
-    }];
-  });
-}
-
-function supportsModes(hostModes: string[] | undefined, requiredModes: string[] | undefined): boolean {
-  if (!requiredModes?.length) return true;
-  const supported = new Set(hostModes ?? []);
-  return requiredModes.every((mode) => supported.has(mode));
-}
-
-function formatRequirement(id: string, modes: string[] | undefined): string {
-  return modes?.length ? `${id}:${modes.join("|")}` : id;
-}
-
 function sessionEvent(event: unknown): Record<string, unknown> {
   if (isRecord(event) && event.type === "host.request") {
     return {

package/src/runtime/types.ts

@@ -2,6 +2,7 @@ import type { JsonValue } from "@rigkit/engine";
 
 export type ServeRuntimeOptions = {
   projectId: string;
+  runtimeFingerprint?: string;
   projectDir: string;
   configPath: string;
   statePath?: string;
@@ -23,6 +24,7 @@ export type RuntimeServer = {
 
 export type RuntimeContext = {
   readonly projectId: string;
+  readonly runtimeFingerprint?: string;
   readonly projectDir: string;
   readonly configPath: string;
   readonly statePath?: string;

package/src/runtime/version.ts

@@ -1 +1 @@
-export const RIGKIT_RUNTIME_VERSION = "0.2.1";
+export const RIGKIT_RUNTIME_VERSION = "0.2.3";

package/src/version.ts

@@ -1 +1 @@
-export const RIGKIT_SDK_VERSION = "0.2.1";
+export const RIGKIT_SDK_VERSION = "0.2.3";