@opencode/server 2.0.3 → 2.0.5

package/dist/api.d.ts

@@ -145,7 +145,7 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     };
     readonly created: import("effect/Schema").Finite;
     readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
-    readonly type: import("effect/Schema").Literal<"catalog.updated">;
+    readonly type: import("effect/Schema").Literal<"provider.updated">;
     readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
         readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
         readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
@@ -167,7 +167,39 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     }>>, never, never>;
     readonly data: import("effect/Schema").Struct<{}>;
 }> & {
-    type: "catalog.updated";
+    type: "provider.updated";
+    durability: "ephemeral";
+    durable: undefined;
+    data: import("effect/Schema").Struct<{}>;
+}, import("effect/Schema").Struct<{
+    readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: import("effect/Schema").Finite;
+    readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+    readonly type: import("effect/Schema").Literal<"model.updated">;
+    readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+        readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: import("effect/Schema").Struct<{}>;
+}> & {
+    type: "model.updated";
     durability: "ephemeral";
     durable: undefined;
     data: import("effect/Schema").Struct<{}>;
@@ -789,7 +821,7 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     };
     readonly created: import("effect/Schema").Finite;
     readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
-    readonly type: import("effect/Schema").Literal<"session.permissions.updated">;
+    readonly type: import("effect/Schema").Literal<"session.permissions">;
     readonly durable: import("effect/Schema").Struct<{
         readonly aggregateID: import("effect/Schema").String;
         readonly seq: import("effect/Schema").brand<import("effect/Schema").Int, "Event.Seq">;
@@ -826,7 +858,7 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
         };
     }>;
 }> & {
-    type: "session.permissions.updated";
+    type: "session.permissions";
     durability: "durable";
     durable: {
         readonly version: number;
@@ -4541,7 +4573,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
         readonly time: import("effect/Schema").Struct<{
             readonly created: import("effect/Schema").Int;
             readonly updated: import("effect/Schema").Int;
-            readonly initialized: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Int>>, import("effect/Schema").optionalKey<import("effect/Schema").Int>, never, never>;
         }>;
         readonly sandboxes: import("effect/Schema").$Array<import("effect/Schema").String>;
     }>;
@@ -4573,7 +4604,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
         readonly time: import("effect/Schema").Struct<{
             readonly created: import("effect/Schema").Int;
             readonly updated: import("effect/Schema").Int;
-            readonly initialized: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Int>>, import("effect/Schema").optionalKey<import("effect/Schema").Int>, never, never>;
         }>;
         readonly sandboxes: import("effect/Schema").$Array<import("effect/Schema").String>;
     }>;
@@ -6156,13 +6186,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     readonly type: import("effect/Schema").TemplateLiteral<readonly ["rpc.", import("effect/Schema").String]>;
     readonly location: import("effect/Schema").Struct<{
         readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-        }>, never, never>;
     }>;
     readonly data: import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>;
 }>, ...import("effect/Schema").Struct<{
@@ -6174,13 +6197,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     readonly metadata: import("effect/Schema").optional<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>;
     readonly location: import("effect/Schema").optional<import("effect/Schema").Struct<{
         readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
-        readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-        }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-        }>, never, never>;
     }>>;
 }>[]]>>, import("effect/Schema").Never, {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
@@ -6199,8 +6215,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     readonly data: {
         readonly form: {
             readonly id: string & import("effect/Brand").Brand<"Form.ID">;
-            readonly sessionID: string;
-            readonly title: string;
             readonly fields: readonly [{
                 readonly type: "string";
                 readonly key: string;
@@ -6380,6 +6394,8 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
                 readonly description?: string | undefined;
                 readonly title?: string | undefined;
             })[]];
+            readonly sessionID: string;
+            readonly title: string;
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
@@ -6466,6 +6482,30 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
+} | {
+    readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+    readonly data: {};
+    readonly type: "provider.updated";
+    readonly created: number;
+    readonly location?: {
+        readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+        readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+    } | undefined;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
+} | {
+    readonly id: string & import("effect/Brand").Brand<"Event.ID">;
+    readonly data: {};
+    readonly type: "model.updated";
+    readonly created: number;
+    readonly location?: {
+        readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
+        readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
+    } | undefined;
+    readonly metadata?: {
+        readonly [x: string]: unknown;
+    } | undefined;
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly data: {
@@ -6529,7 +6569,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
         readonly time: {
             readonly created: number;
             readonly updated: number;
-            readonly initialized?: number | undefined;
         };
         readonly sandboxes: readonly string[];
         readonly name?: string | undefined;
@@ -6765,7 +6804,7 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
         readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
         readonly version: number & import("effect/Brand").Brand<"Event.Version">;
     };
-    readonly type: "session.permissions.updated";
+    readonly type: "session.permissions";
     readonly created: number;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
@@ -7959,18 +7998,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-} | {
-    readonly id: string & import("effect/Brand").Brand<"Event.ID">;
-    readonly data: {};
-    readonly type: "catalog.updated";
-    readonly created: number;
-    readonly location?: {
-        readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-        readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
-    } | undefined;
-    readonly metadata?: {
-        readonly [x: string]: unknown;
-    } | undefined;
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly data: {};
@@ -8370,7 +8397,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly location: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-        readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
     };
     readonly data: {
         readonly [x: string]: unknown;
@@ -8386,7 +8412,6 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     readonly type: "server.connected";
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-        readonly workspaceID?: (string & import("effect/Brand").Brand<"Workspace.ID">) | undefined;
     } | undefined;
     readonly metadata?: {
         readonly [x: string]: unknown;

package/dist/handlers/config.js

@@ -3,16 +3,11 @@ import { ShellSelect } from "@opencode/core/shell/select";
 import { Effect } from "effect";
 import { HttpApiBuilder } from "effect/unstable/httpapi";
 import { Api } from "../api";
-export const ConfigHandler = HttpApiBuilder.group(Api, "server.config", (handlers) => handlers.handle("config.get", () => Config.Service.use((config) => config.entries())).handle("config.preferences", Effect.fn(function* () {
+export const ConfigHandler = HttpApiBuilder.group(Api, "server.config", (handlers) => handlers.handle("config.get", () => Config.Service.use((config) => config.entries())).handle("config.update", Effect.fn(function* (ctx) {
   const config = yield* Config.Service;
-  if (!config.preferences)
-    return yield* Effect.die(Error("Config preferences are unavailable"));
-  return yield* config.preferences().pipe(Effect.orDie);
-})).handle("config.updatePreferences", Effect.fn(function* (ctx) {
-  const config = yield* Config.Service;
-  if (!config.updatePreferences)
-    return yield* Effect.die(Error("Config preference updates are unavailable"));
-  return yield* config.updatePreferences(ctx.payload).pipe(Effect.orDie);
+  if (!config.update)
+    return yield* Effect.die(Error("Config updates are unavailable"));
+  return yield* config.update(ctx.payload).pipe(Effect.orDie);
 })).handle("config.shells", Effect.fn(function* () {
   const shell = yield* ShellSelect.Service;
   if (!shell.list)

package/dist/handlers/credential.d.ts

@@ -1 +1,2 @@
-export declare const CredentialHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.credential">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;
+import { Credential } from "@opencode/core/credential";
+export declare const CredentialHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.credential">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("effect/unstable/http/HttpRouter").Request<"Requires", Credential.Service>>;

package/dist/handlers/credential.js

@@ -1,14 +1,14 @@
-import { Integration } from "@opencode/core/integration";
+import { Credential } from "@opencode/core/credential";
 import { Effect } from "effect";
 import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
 import { Api } from "../api";
 export const CredentialHandler = HttpApiBuilder.group(Api, "server.credential", (handlers) => handlers.handle("credential.update", Effect.fn(function* (ctx) {
-  yield* (yield* Integration.Service).connection.update(ctx.params.credentialID, { label: ctx.payload.label });
+  yield* (yield* Credential.Service).update(ctx.params.credentialID, { label: ctx.payload.label });
   return HttpApiSchema.NoContent.make();
 })).handle("credential.activate", Effect.fn(function* (ctx) {
-  yield* (yield* Integration.Service).connection.activate(ctx.params.credentialID);
+  yield* (yield* Credential.Service).activate(ctx.params.credentialID);
   return HttpApiSchema.NoContent.make();
 })).handle("credential.remove", Effect.fn(function* (ctx) {
-  yield* (yield* Integration.Service).connection.remove(ctx.params.credentialID);
+  yield* (yield* Credential.Service).remove(ctx.params.credentialID);
   return HttpApiSchema.NoContent.make();
 })));

package/dist/handlers/form.d.ts

@@ -1,4 +1 @@
-import { Instance } from "@opencode/core/instance/service";
-import { LocationServiceMap } from "@opencode/core/location-services";
-import { Session } from "@opencode/core/session";
-export declare const FormHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.form">, never, LocationServiceMap.Service | Session.Service | Instance.Service | import("../location").LocationMiddleware | (import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../middleware/form-location").FormLocationMiddleware)>;
+export declare const FormHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.form">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;

package/dist/handlers/form.js

@@ -1,61 +1,9 @@
 import { Form } from "@opencode/core/form";
-import { Instance } from "@opencode/core/instance/service";
-import { LocationServiceMap } from "@opencode/core/location-services";
-import { Session } from "@opencode/core/session";
-import {
-  ConflictError,
-  FormAlreadySettledError,
-  FormInvalidAnswerError,
-  FormNotFoundError,
-  InvalidRequestError
-} from "@opencode/protocol/errors";
 import { Effect } from "effect";
-import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
 import { Api } from "../api";
-import { requestRef, response, sessionInfo } from "../location";
-function missingForm(id) {
-  return new FormNotFoundError({ id, message: `Form not found: ${id}` });
-}
-export const FormHandler = HttpApiBuilder.group(Api, "server.form", (handlers) => Effect.gen(function* () {
-  const locations = yield* LocationServiceMap.Service, instances = yield* Instance.Service, sessions = yield* Session.Service, requireOwnedForm = Effect.fnUntraced(function* (sessionID, formID) {
-    const form = yield* Form.Service, info = yield* form.get(formID).pipe(Effect.catchTag("Form.NotFoundError", () => missingForm(formID)));
-    if (info.sessionID !== sessionID)
-      return yield* missingForm(formID);
-    return { form, info };
-  });
-  return handlers.handle("form.request.list", Effect.fn(function* () {
-    const form = yield* Form.Service;
-    return yield* response(form.list());
-  })).handle("session.form.list", Effect.fn(function* (ctx) {
-    const session = ctx.params.sessionID === "global" ? void 0 : yield* sessionInfo(sessions, ctx.params.sessionID), read = Form.Service.use((form) => form.list({ sessionID: ctx.params.sessionID }));
-    return { data: yield* session ? read.pipe(instances.provide(session)) : read.pipe(Effect.provide(locations.get(requestRef(ctx.request)))) };
-  })).handle("session.form.create", Effect.fn(function* (ctx) {
-    return { data: yield* (yield* Form.Service).create({
-      id: ctx.payload.id,
-      sessionID: ctx.params.sessionID,
-      title: ctx.payload.title,
-      metadata: ctx.payload.metadata,
-      fields: ctx.payload.fields
-    }).pipe(Effect.catchTags({
-      "Form.AlreadyExistsError": (error) => new ConflictError({ resource: error.id, message: error.message }),
-      "Form.InvalidFormError": (error) => new InvalidRequestError({ message: error.message, field: "fields" })
-    })) };
-  })).handle("session.form.get", Effect.fn(function* (ctx) {
-    return { data: (yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID)).info };
-  })).handle("session.form.state", Effect.fn(function* (ctx) {
-    return { data: yield* (yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID)).form.state(ctx.params.formID).pipe(Effect.catchTag("Form.NotFoundError", () => missingForm(ctx.params.formID))) };
-  })).handle("session.form.reply", Effect.fn(function* (ctx) {
-    yield* (yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID)).form.reply({ id: ctx.params.formID, answer: ctx.payload.answer }).pipe(Effect.catchTags({
-      "Form.AlreadySettledError": (error) => new FormAlreadySettledError({ id: error.id, message: error.message }),
-      "Form.InvalidAnswerError": (error) => new FormInvalidAnswerError({ id: error.id, message: error.message }),
-      "Form.NotFoundError": () => missingForm(ctx.params.formID)
-    }));
-    return HttpApiSchema.NoContent.make();
-  })).handle("session.form.cancel", Effect.fn(function* (ctx) {
-    yield* (yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID)).form.cancel(ctx.params.formID).pipe(Effect.catchTags({
-      "Form.AlreadySettledError": (error) => new FormAlreadySettledError({ id: error.id, message: error.message }),
-      "Form.NotFoundError": () => missingForm(ctx.params.formID)
-    }));
-    return HttpApiSchema.NoContent.make();
-  }));
-}));
+import { response } from "../location";
+export const FormHandler = HttpApiBuilder.group(Api, "server.form", (handlers) => handlers.handle("form.list", Effect.fn(function* () {
+  const form = yield* Form.Service;
+  return yield* response(form.list());
+})));

package/dist/handlers/integration.js

@@ -2,7 +2,12 @@ import { Integration } from "@opencode/core/integration";
 import { Effect } from "effect";
 import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
 import { Api } from "../api";
-import { InvalidRequestError } from "@opencode/protocol/errors";
+import {
+  IntegrationAttemptNotFoundError,
+  IntegrationMethodNotFoundError,
+  IntegrationNotFoundError,
+  InvalidRequestError
+} from "@opencode/protocol/errors";
 import { response } from "../location";
 import { WellKnown } from "@opencode/core/wellknown";
 const authorize = (effect) => effect.pipe(Effect.mapError((error) => new InvalidRequestError({
@@ -14,8 +19,13 @@ export const IntegrationHandler = HttpApiBuilder.group(Api, "server.integration"
     const service = yield* Integration.Service;
     return yield* response(service.list());
   })).handle("integration.get", Effect.fn(function* (ctx) {
-    const service = yield* Integration.Service;
-    return yield* response(service.get(ctx.params.integrationID));
+    const integration = yield* (yield* Integration.Service).get(ctx.params.integrationID);
+    if (!integration)
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
+    return yield* response(Effect.succeed(integration));
   })).handle("integration.wellknown.add", Effect.fn(function* (ctx) {
     const wellknown = yield* WellKnown.Service, integration = yield* Integration.Service;
     yield* wellknown.add(ctx.payload.url).pipe(Effect.mapError((error) => new InvalidRequestError({ message: error.message, kind: "well_known_discovery" })));
@@ -23,6 +33,11 @@ export const IntegrationHandler = HttpApiBuilder.group(Api, "server.integration"
     return HttpApiSchema.NoContent.make();
   })).handle("integration.connect.key", Effect.fn(function* (ctx) {
     const service = yield* Integration.Service;
+    if (!(yield* service.get(ctx.params.integrationID)))
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
     yield* authorize(service.connection.key({
       integrationID: ctx.params.integrationID,
       key: ctx.payload.key,
@@ -40,19 +55,42 @@ export const IntegrationHandler = HttpApiBuilder.group(Api, "server.integration"
     })));
   })).handle("integration.oauth.status", Effect.fn(function* (ctx) {
     const service = yield* Integration.Service;
+    if (!(yield* service.get(ctx.params.integrationID)))
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
     return yield* response(service.oauth.status({
       integrationID: ctx.params.integrationID,
       attemptID: ctx.params.attemptID
-    }));
+    }).pipe(Effect.mapError((error) => new IntegrationAttemptNotFoundError({
+      integrationID: error.integrationID,
+      attemptID: error.attemptID,
+      message: `OAuth attempt not found: ${error.attemptID}`
+    }))));
   })).handle("integration.oauth.complete", Effect.fn(function* (ctx) {
-    yield* (yield* Integration.Service).oauth.complete({
+    const service = yield* Integration.Service;
+    if (!(yield* service.get(ctx.params.integrationID)))
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
+    yield* service.oauth.complete({
       integrationID: ctx.params.integrationID,
       attemptID: ctx.params.attemptID,
       code: ctx.payload.code
-    }).pipe(Effect.mapError((error) => new InvalidRequestError({
-      message: error._tag === "Integration.CodeRequired" ? "Authorization code is required" : "Authentication failed",
-      kind: error._tag === "Integration.CodeRequired" ? "integration_code_required" : "integration_authorization"
-    })));
+    }).pipe(Effect.mapError((error) => {
+      if (error._tag === "Integration.AttemptNotFound")
+        return new IntegrationAttemptNotFoundError({
+          integrationID: error.integrationID,
+          attemptID: error.attemptID,
+          message: `OAuth attempt not found: ${error.attemptID}`
+        });
+      return new InvalidRequestError({
+        message: error._tag === "Integration.CodeRequired" ? "Authorization code is required" : "Authentication failed",
+        kind: error._tag === "Integration.CodeRequired" ? "integration_code_required" : "integration_authorization"
+      });
+    }));
     return HttpApiSchema.NoContent.make();
   })).handle("integration.oauth.cancel", Effect.fn(function* (ctx) {
     yield* (yield* Integration.Service).oauth.cancel({
@@ -61,7 +99,18 @@ export const IntegrationHandler = HttpApiBuilder.group(Api, "server.integration"
     });
     return HttpApiSchema.NoContent.make();
   })).handle("integration.command.connect", Effect.fn(function* (ctx) {
-    const service = yield* Integration.Service;
+    const service = yield* Integration.Service, integration = yield* service.get(ctx.params.integrationID);
+    if (!integration)
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
+    if (!integration.methods.some((method) => method.type === "command" && method.id === ctx.payload.methodID))
+      return yield* new IntegrationMethodNotFoundError({
+        integrationID: ctx.params.integrationID,
+        methodID: ctx.payload.methodID,
+        message: `Integration method not found: ${ctx.payload.methodID}`
+      });
     return yield* response(authorize(service.command.connect({
       integrationID: ctx.params.integrationID,
       methodID: ctx.payload.methodID,
@@ -69,10 +118,19 @@ export const IntegrationHandler = HttpApiBuilder.group(Api, "server.integration"
     })));
   })).handle("integration.command.status", Effect.fn(function* (ctx) {
     const service = yield* Integration.Service;
+    if (!(yield* service.get(ctx.params.integrationID)))
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
     return yield* response(service.command.status({
       integrationID: ctx.params.integrationID,
       attemptID: ctx.params.attemptID
-    }));
+    }).pipe(Effect.mapError((error) => new IntegrationAttemptNotFoundError({
+      integrationID: error.integrationID,
+      attemptID: error.attemptID,
+      message: `Command attempt not found: ${error.attemptID}`
+    }))));
   })).handle("integration.command.cancel", Effect.fn(function* (ctx) {
     yield* (yield* Integration.Service).command.cancel({
       integrationID: ctx.params.integrationID,

package/dist/handlers/location.js

@@ -6,7 +6,6 @@ export const LocationHandler = HttpApiBuilder.group(Api, "server.location", (han
   const location = yield* Location.Service;
   return new Location.Info({
     directory: location.directory,
-    workspaceID: location.workspaceID,
     project: location.project
   });
 })));

package/dist/handlers/model.js

@@ -1,14 +1,14 @@
-import { Catalog } from "@opencode/core/catalog";
+import { Model } from "@opencode/core/model";
 import { Effect } from "effect";
 import { HttpApiBuilder } from "effect/unstable/httpapi";
 import { Api } from "../api";
 import { response } from "../location";
 export const ModelHandler = HttpApiBuilder.group(Api, "server.model", (handlers) => Effect.gen(function* () {
   return handlers.handle("model.list", Effect.fn(function* () {
-    const catalog = yield* Catalog.Service;
-    return yield* response(catalog.model.available());
+    const models = yield* Model.Service;
+    return yield* response(models.available());
   })).handle("model.default", Effect.fn(function* () {
-    const catalog = yield* Catalog.Service;
-    return yield* response(catalog.model.default());
+    const models = yield* Model.Service;
+    return yield* response(models.default());
   }));
 }));

package/dist/handlers/permission.d.ts

@@ -1,4 +1,4 @@
 import { Instance } from "@opencode/core/instance/service";
 import { PermissionSaved } from "@opencode/core/permission/saved";
 import { Session } from "@opencode/core/session";
-export declare const PermissionHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.permission">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | Session.Service | Instance.Service | import("../location").LocationMiddleware | import("../middleware/session-location").SessionLocationMiddleware | import("effect/unstable/http/HttpRouter").Request<"Requires", PermissionSaved.Service>>;
+export declare const PermissionHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.permission">, never, Session.Service | Instance.Service | import("../middleware/session-location").SessionLocationMiddleware | (import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware | import("effect/unstable/http/HttpRouter").Request<"Requires", PermissionSaved.Service>)>;

package/dist/handlers/permission.js

@@ -41,10 +41,7 @@ export const PermissionHandler = HttpApiBuilder.group(Api, "server.permission",
   })).handle("session.permission.get", Effect.fn(function* (ctx) {
     return { data: (yield* requireOwnedRequest(ctx.params.sessionID, ctx.params.requestID)).request };
   })).handle("session.permission.reply", Effect.fn(function* (ctx) {
-    yield* (yield* requireOwnedRequest(ctx.params.sessionID, ctx.params.requestID)).permission.reply({ requestID: ctx.params.requestID, reply: ctx.payload.reply, message: ctx.payload.message }).pipe(Effect.catchTag("Permission.NotFoundError", () => missingRequest(ctx.params.requestID)));
-    return HttpApiSchema.NoContent.make();
-  })).handle("session.permission.rules", Effect.fn(function* (ctx) {
-    yield* sessions.setPermissions({ sessionID: ctx.params.sessionID, permissions: ctx.payload.permissions }).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
+    yield* (yield* requireOwnedRequest(ctx.params.sessionID, ctx.params.requestID)).permission.reply({ requestID: ctx.params.requestID, reply: ctx.payload.decision, message: ctx.payload.message }).pipe(Effect.catchTag("Permission.NotFoundError", () => missingRequest(ctx.params.requestID)));
     return HttpApiSchema.NoContent.make();
   })).handle("permission.saved.list", Effect.fn(function* (ctx) {
     const location = yield* Location.Service;

package/dist/handlers/plugin.js

@@ -7,10 +7,8 @@ import { Api } from "../api";
 import { response } from "../location";
 export const PluginHandler = HttpApiBuilder.group(Api, "server.plugin", (handlers) => handlers.handle("plugin.list", () => Effect.gen(function* () {
   return yield* response(Plugin.Service.use((plugin) => plugin.list()));
-})).handle("plugin.awaitActivation", () => Plugin.awaitActivation).handle("plugin.check", (ctx) => Effect.gen(function* () {
-  const plugins = yield* Plugin.Service;
-  yield* plugins.awaitActivation;
-  const inventory = yield* plugins.list(), targets = [
+})).handle("plugin.check", (ctx) => Effect.gen(function* () {
+  const inventory = yield* (yield* Plugin.Service).list(), targets = [
     ...new Set(inventory.flatMap((plugin) => plugin.source.type === "package" ? [plugin.source.target] : []))
   ].filter((target) => ctx.payload.target === void 0 || target === ctx.payload.target);
   if (ctx.payload.target !== void 0 && !targets.length)
@@ -34,9 +32,7 @@ export const PluginHandler = HttpApiBuilder.group(Api, "server.plugin", (handler
     };
   })));
 })).handle("plugin.update", (ctx) => Effect.gen(function* () {
-  const plugins = yield* Plugin.Service;
-  yield* plugins.awaitActivation;
-  const inventory = new Set((yield* plugins.list()).flatMap((plugin) => plugin.source.type === "package" ? [plugin.source.target] : [])), unknown = ctx.payload.targets.filter((target) => !inventory.has(target));
+  const plugins = yield* Plugin.Service, inventory = new Set((yield* plugins.list()).flatMap((plugin) => plugin.source.type === "package" ? [plugin.source.target] : [])), unknown = ctx.payload.targets.filter((target) => !inventory.has(target));
   if (unknown.length)
     return yield* new InvalidRequestError({
       message: `Plugin packages are not in the current server inventory: ${unknown.join(", ")}`,

package/dist/handlers/project.d.ts

@@ -1,2 +1,2 @@
 import { Project } from "@opencode/core/project";
-export declare const ProjectHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.project">, never, import("effect/unstable/http/HttpRouter").Request<"Requires", Project.Service> | (import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware)>;
+export declare const ProjectHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.project">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware | import("effect/unstable/http/HttpRouter").Request<"Requires", Project.Service>>;

package/dist/handlers/project.js

@@ -1,4 +1,3 @@
-import { Location } from "@opencode/core/location";
 import { Project } from "@opencode/core/project";
 import { Effect } from "effect";
 import { HttpApiBuilder } from "effect/unstable/httpapi";
@@ -7,8 +6,4 @@ import { ProjectNotFoundError } from "@opencode/protocol/errors";
 export const ProjectHandler = HttpApiBuilder.group(Api, "server.project", (handlers) => handlers.handle("project.list", () => Project.Service.use((project) => project.list())).handle("project.update", (ctx) => Project.Service.use((project) => project.update({ ...ctx.payload, projectID: ctx.params.projectID }).pipe(Effect.mapError(() => new ProjectNotFoundError({
   projectID: ctx.params.projectID,
   message: `Project not found: ${ctx.params.projectID}`
-}))))).handle("project.current", () => Location.Service.use((location) => Effect.succeed({
-  id: location.project.id,
-  directory: location.project.directory,
-  canonical: location.project.canonical
-}))));
+}))))));

package/dist/handlers/provider.js

@@ -1,4 +1,4 @@
-import { Catalog } from "@opencode/core/catalog";
+import { Provider } from "@opencode/core/provider";
 import { ProviderNotFoundError } from "@opencode/protocol/errors";
 import { Effect } from "effect";
 import { HttpApiBuilder } from "effect/unstable/httpapi";
@@ -6,10 +6,10 @@ import { Api } from "../api";
 import { response } from "../location";
 export const ProviderHandler = HttpApiBuilder.group(Api, "server.provider", (handlers) => Effect.gen(function* () {
   return handlers.handle("provider.list", Effect.fn(function* () {
-    const catalog = yield* Catalog.Service;
-    return yield* response(catalog.provider.available());
+    const providers = yield* Provider.Service;
+    return yield* response(providers.available());
   })).handle("provider.get", Effect.fn(function* (ctx) {
-    const provider = yield* (yield* Catalog.Service).provider.get(ctx.params.providerID);
+    const provider = yield* (yield* Provider.Service).get(ctx.params.providerID);
     if (!provider)
       return yield* new ProviderNotFoundError({
         providerID: ctx.params.providerID,

package/dist/handlers/server.js

@@ -2,6 +2,11 @@ import { Effect } from "effect";
 import { HttpApiBuilder } from "effect/unstable/httpapi";
 import { Api } from "../api";
 import { ServerInfo } from "../server-info";
-export const ServerHandler = HttpApiBuilder.group(Api, "server.server", (handlers) => handlers.handle("server.get", () => Effect.gen(function* () {
-  return { urls: (yield* ServerInfo.Service).urls() };
+export const ServerHandler = HttpApiBuilder.group(Api, "server.server", (handlers) => handlers.handle("server.status", () => Effect.gen(function* () {
+  const info = yield* ServerInfo.Service;
+  return {
+    version: info.app.version ?? "unknown",
+    pid: process.pid ?? 0,
+    urls: info.urls()
+  };
 })));

package/dist/handlers/session.d.ts

@@ -1,3 +1,3 @@
 import { Session } from "@opencode/core/session";
 import { SessionTransfer } from "@opencode/core/session/transfer";
-export declare const SessionHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.session">, never, Session.Service | import("../middleware/session-location").SessionLocationMiddleware | SessionTransfer.Service | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/database/database").Service> | (import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization)>;
+export declare const SessionHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.session">, never, Session.Service | import("../middleware/session-location").SessionLocationMiddleware | SessionTransfer.Service | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/database/database").Service> | (import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../middleware/form-location").FormLocationMiddleware)>;

package/dist/handlers/session.js

@@ -3,6 +3,7 @@ import { SessionStats } from "@opencode/core/session/stats";
 import { SessionTitle } from "@opencode/core/session/title";
 import { SessionTransfer } from "@opencode/core/session/transfer";
 import { InstructionEntry } from "@opencode/core/session/instruction-entry";
+import { Form } from "@opencode/core/form";
 import { DateTime, Effect, Stream } from "effect";
 import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
 import { Api } from "../api";
@@ -11,6 +12,9 @@ import {
   ConflictError,
   CommandExecutionError,
   CommandNotFoundError,
+  FormAlreadySettledError,
+  FormInvalidAnswerError,
+  FormNotFoundError,
   InvalidRequestError,
   InvalidCursorError,
   MessageNotFoundError,
@@ -21,15 +25,22 @@ import {
 import { AbsolutePath } from "@opencode/core/schema";
 import { failedMessageDecode, failedSnapshot, missingMessage, missingSession } from "./session-error";
 const DefaultSessionsLimit = 50;
+function missingForm(id) {
+  return new FormNotFoundError({ id, message: `Form not found: ${id}` });
+}
 export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handlers) => Effect.gen(function* () {
-  const session = yield* Session.Service, transfer = yield* SessionTransfer.Service, busySession = (error) => new SessionBusyError({
+  const session = yield* Session.Service, transfer = yield* SessionTransfer.Service, requireOwnedForm = Effect.fnUntraced(function* (sessionID, formID) {
+    const form = yield* Form.Service, info = yield* form.get(formID).pipe(Effect.catchTag("Form.NotFoundError", () => missingForm(formID)));
+    if (info.sessionID !== sessionID)
+      return yield* missingForm(formID);
+    return { form, info };
+  }), busySession = (error) => new SessionBusyError({
     sessionID: error.sessionID,
     message: `Session is busy: ${error.sessionID}`
   }), pendingMutation = (effect, conflict) => effect.pipe(Effect.catchTag("Session.NotFoundError", missingSession), Effect.catchTag("Session.InboxConflictError", (error) => new ConflictError({ resource: error.inboxID, message: `${conflict}: ${error.inboxID}` })), Effect.as(HttpApiSchema.NoContent.make()));
   return handlers.handle("session.list", Effect.fn(function* (ctx) {
     const query = ctx.query.cursor !== void 0 ? yield* SessionsCursor.parse(ctx.query.cursor).pipe(Effect.mapError(() => new InvalidCursorError({ message: "Invalid cursor" }))) : ctx.query, sessions = (yield* session.list({
       ...query,
-      workspaceID: query.workspace,
       limit: ctx.query.limit ?? DefaultSessionsLimit
     })).data, first = sessions[0], last = sessions.at(-1);
     return {
@@ -104,7 +115,7 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
       data: yield* session.get(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession))
     };
   })).handle("session.view", Effect.fn(function* (ctx) {
-    yield* session.view({ sessionID: ctx.params.sessionID, idle: ctx.payload.idle }).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
+    yield* session.view({ sessionID: ctx.params.sessionID, idle: DateTime.toEpochMillis(ctx.payload.idle) }).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
     return HttpApiSchema.NoContent.make();
   })).handle("session.remove", Effect.fn(function* (ctx) {
     yield* session.remove(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
@@ -114,7 +125,7 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
     return HttpApiSchema.NoContent.make();
   })).handle("session.fork", Effect.fn(function* (ctx) {
     return {
-      data: yield* session.fork({ sessionID: ctx.params.sessionID, boundary: ctx.payload.boundary }).pipe(Effect.catchTag("Session.NotFoundError", missingSession), Effect.catchTag("Session.MessageNotFoundError", missingMessage), Effect.catchTag("Session.ForkEmptyError", (error) => new InvalidRequestError({ message: error.message, kind: "empty_session" })))
+      data: yield* session.fork({ sessionID: ctx.params.sessionID, before: ctx.payload.before }).pipe(Effect.catchTag("Session.NotFoundError", missingSession), Effect.catchTag("Session.MessageNotFoundError", missingMessage), Effect.catchTag("Session.ForkEmptyError", (error) => new InvalidRequestError({ message: error.message, kind: "empty_session" })))
     };
   })).handle("session.switchAgent", Effect.fn(function* (ctx) {
     yield* session.switchAgent({ sessionID: ctx.params.sessionID, agent: ctx.payload.agent }).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
@@ -122,18 +133,20 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
   })).handle("session.switchModel", Effect.fn(function* (ctx) {
     yield* session.switchModel({ sessionID: ctx.params.sessionID, model: ctx.payload.model }).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
     return HttpApiSchema.NoContent.make();
-  })).handle("session.rename", Effect.fn(function* (ctx) {
-    if (ctx.payload.title) {
-      yield* session.rename({ sessionID: ctx.params.sessionID, title: ctx.payload.title }).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
-      return HttpApiSchema.NoContent.make();
-    }
-    yield* (yield* SessionTitle.Service).generate(ctx.params.sessionID);
+  })).handle("session.update", Effect.fn(function* (ctx) {
+    yield* session.get(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
+    if (ctx.payload.title !== void 0)
+      if (ctx.payload.title)
+        yield* session.rename({ sessionID: ctx.params.sessionID, title: ctx.payload.title }).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
+      else
+        yield* (yield* SessionTitle.Service).generate(ctx.params.sessionID);
+    if (ctx.payload.permissions !== void 0)
+      yield* session.setPermissions({ sessionID: ctx.params.sessionID, permissions: ctx.payload.permissions }).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
     return HttpApiSchema.NoContent.make();
   })).handle("session.move", Effect.fn(function* (ctx) {
     yield* session.move({
       sessionID: ctx.params.sessionID,
       directory: ctx.payload.directory,
-      workspaceID: ctx.payload.workspaceID,
       delivery: ctx.payload.delivery
     }).pipe(Effect.catchTag("Session.NotFoundError", missingSession), Effect.catchTag("Session.DestinationNotFoundError", (error) => Effect.fail(new InvalidRequestError({ message: `Directory does not exist: ${error.directory}` }))), Effect.catchTag("Session.DestinationNotDirectoryError", (error) => Effect.fail(new InvalidRequestError({ message: `Not a directory: ${error.directory}` }))), Effect.catchTag("Session.DestinationUnavailableError", (error) => Effect.fail(new InvalidRequestError({ message: `Directory is unavailable: ${error.directory}` }))));
     return HttpApiSchema.NoContent.make();
@@ -157,7 +170,7 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
   })).handle("session.command", Effect.fn(function* (ctx) {
     yield* session.command({
       sessionID: ctx.params.sessionID,
-      command: ctx.payload.command,
+      command: ctx.payload.name,
       text: ctx.payload.text,
       files: ctx.payload.files,
       agents: ctx.payload.agents,
@@ -174,8 +187,7 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
   })).handle("session.skill", Effect.fn(function* (ctx) {
     yield* session.skill({
       sessionID: ctx.params.sessionID,
-      id: ctx.payload.id,
-      skill: ctx.payload.skill,
+      skill: ctx.payload.id,
       resume: ctx.payload.resume
     }).pipe(Effect.catchTag("Session.NotFoundError", missingSession), Effect.catchTag("Session.SkillNotFoundError", (error) => Effect.fail(new SkillNotFoundError({ skill: error.skill, message: `Skill not found: ${error.skill}` }))));
     return HttpApiSchema.NoContent.make();
@@ -235,11 +247,10 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
       data: yield* session.inbox(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession))
     };
   })).handle("session.inbox.cancel", Effect.fn(function* (ctx) {
-    return yield* pendingMutation(session.cancelInbox({ sessionID: ctx.params.sessionID, inboxID: ctx.params.inboxID }), "Pending input can no longer be cancelled");
-  })).handle("session.inbox.steer", Effect.fn(function* (ctx) {
-    return yield* pendingMutation(session.steerInbox({ sessionID: ctx.params.sessionID, inboxID: ctx.params.inboxID }), "Pending input is no longer queued");
-  })).handle("session.inbox.queue", Effect.fn(function* (ctx) {
-    return yield* pendingMutation(session.queueInbox({ sessionID: ctx.params.sessionID, inboxID: ctx.params.inboxID }), "Pending input is no longer a steer");
+    yield* session.cancelInbox({ sessionID: ctx.params.sessionID, inboxID: ctx.params.inboxID }).pipe(Effect.catchTag("Session.NotFoundError", missingSession), Effect.catchTag("Session.InboxConflictError", () => Effect.void));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.inbox.update", Effect.fn(function* (ctx) {
+    return yield* pendingMutation(ctx.payload.delivery === "steer" ? session.steerInbox({ sessionID: ctx.params.sessionID, inboxID: ctx.params.inboxID }) : session.queueInbox({ sessionID: ctx.params.sessionID, inboxID: ctx.params.inboxID }), `Pending input cannot change to ${ctx.payload.delivery}`);
   })).handle("session.instructions.entry.list", Effect.fn(function* (ctx) {
     return { data: yield* (yield* InstructionEntry.Service).list(ctx.params.sessionID) };
   })).handle("session.instructions.entry.put", Effect.fn(function* (ctx) {
@@ -254,7 +265,7 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
     yield* session.get(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
     return session.log({ sessionID: ctx.params.sessionID, after: ctx.query.after, follow: ctx.query.follow }).pipe(Stream.orDie);
   })).handle("session.interrupt", Effect.fn(function* (ctx) {
-    return { interrupted: yield* session.interrupt(ctx.params.sessionID, { continue: ctx.query.continue }) };
+    return { interrupted: yield* session.interrupt(ctx.params.sessionID, { resume: ctx.query.resume }) };
   })).handle("session.background", Effect.fn(function* (ctx) {
     yield* session.background(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
     return HttpApiSchema.NoContent.make();
@@ -268,5 +279,34 @@ export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handl
       messageID: ctx.params.messageID,
       message: `Message not found: ${ctx.params.messageID}`
     });
+  })).handle("session.form.list", Effect.fn(function* (ctx) {
+    return { data: yield* (yield* Form.Service).list({ sessionID: ctx.params.sessionID }) };
+  })).handle("session.form.create", Effect.fn(function* (ctx) {
+    return { data: yield* (yield* Form.Service).create({
+      id: ctx.payload.id,
+      sessionID: ctx.params.sessionID,
+      title: ctx.payload.title,
+      metadata: ctx.payload.metadata,
+      fields: ctx.payload.fields
+    }).pipe(Effect.catchTags({
+      "Form.AlreadyExistsError": (error) => new ConflictError({ resource: error.id, message: error.message }),
+      "Form.InvalidFormError": (error) => new InvalidRequestError({ message: error.message, field: "fields" })
+    })) };
+  })).handle("session.form.get", Effect.fn(function* (ctx) {
+    const owned = yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID), state = yield* owned.form.state(ctx.params.formID).pipe(Effect.catchTag("Form.NotFoundError", () => missingForm(ctx.params.formID)));
+    return { data: { ...owned.info, state } };
+  })).handle("session.form.reply", Effect.fn(function* (ctx) {
+    yield* (yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID)).form.reply({ id: ctx.params.formID, answer: ctx.payload.answer }).pipe(Effect.catchTags({
+      "Form.AlreadySettledError": (error) => new FormAlreadySettledError({ id: error.id, message: error.message }),
+      "Form.InvalidAnswerError": (error) => new FormInvalidAnswerError({ id: error.id, message: error.message }),
+      "Form.NotFoundError": () => missingForm(ctx.params.formID)
+    }));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.form.cancel", Effect.fn(function* (ctx) {
+    yield* (yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID)).form.cancel(ctx.params.formID).pipe(Effect.catchTags({
+      "Form.AlreadySettledError": (error) => new FormAlreadySettledError({ id: error.id, message: error.message }),
+      "Form.NotFoundError": () => missingForm(ctx.params.formID)
+    }));
+    return HttpApiSchema.NoContent.make();
   }));
 }));

package/dist/handlers/shell.js

@@ -15,14 +15,11 @@ export const ShellHandler = HttpApiBuilder.group(Api, "server.shell", (handlers)
   })).handle("shell.get", Effect.fn(function* (ctx) {
     const shell = yield* Shell.Service;
     return yield* response(shell.get(ctx.params.id).pipe(Effect.catchTag("Shell.NotFoundError", () => new ShellNotFoundError({ id: ctx.params.id, message: `Shell command not found: ${ctx.params.id}` }))));
-  })).handle("shell.timeout", Effect.fn(function* (ctx) {
-    const shell = yield* Shell.Service;
-    return yield* response(shell.timeout(ctx.params.id, ctx.payload.timeout).pipe(Effect.catchTag("Shell.NotFoundError", () => new ShellNotFoundError({ id: ctx.params.id, message: `Shell command not found: ${ctx.params.id}` }))));
   })).handle("shell.output", Effect.fn(function* (ctx) {
     const shell = yield* Shell.Service;
     return yield* response(shell.output(ctx.params.id, { cursor: ctx.query.cursor, limit: ctx.query.limit }).pipe(Effect.catchTag("Shell.NotFoundError", () => new ShellNotFoundError({ id: ctx.params.id, message: `Shell command not found: ${ctx.params.id}` }))));
   })).handle("shell.remove", Effect.fn(function* (ctx) {
-    yield* (yield* Shell.Service).remove(ctx.params.id).pipe(Effect.catchTag("Shell.NotFoundError", () => new ShellNotFoundError({ id: ctx.params.id, message: `Shell command not found: ${ctx.params.id}` })));
+    yield* (yield* Shell.Service).remove(ctx.params.id).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.void));
     return HttpApiSchema.NoContent.make();
   }));
 }));

package/dist/handlers/vcs.js

@@ -11,7 +11,7 @@ export const VcsHandler = HttpApiBuilder.group(Api, "server.vcs", (handlers) =>
     return yield* (yield* Vcs.Service).base().pipe(Effect.mapError((error) => new ServiceUnavailableError({ service: "vcs", message: error.message })));
   }))).handle("vcs.status", () => response(Effect.gen(function* () {
     return yield* (yield* Vcs.Service).status();
-  }))).handle("vcs.branches", (ctx) => response(Effect.gen(function* () {
+  }))).handle("vcs.branch.list", (ctx) => response(Effect.gen(function* () {
     return yield* (yield* Vcs.Service).branches({ search: ctx.query.search, limit: Math.min(ctx.query.limit ?? 50, 100) });
   }))).handle("vcs.diff", (ctx) => response(Effect.gen(function* () {
     return yield* (yield* Vcs.Service).diff(ctx.query.mode, { context: ctx.query.context, base: ctx.query.base }).pipe(Effect.mapError((error) => new ServiceUnavailableError({ service: "vcs", message: error.message })));

package/dist/handlers/worktree.d.ts

@@ -1 +1,2 @@
-export declare const WorktreeHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.worktree">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;
+import { Worktree } from "@opencode/core/worktree";
+export declare const WorktreeHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.worktree">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | Worktree.Service>;

package/dist/handlers/worktree.js

@@ -1,20 +1,17 @@
 import { Git } from "@opencode/core/git";
 import { Worktree } from "@opencode/core/worktree";
-import { Plugin } from "@opencode/core/plugin";
+import { Project } from "@opencode/core/project";
+import { ProjectNotFoundError } from "@opencode/protocol/errors";
 import { WorktreeError } from "@opencode/protocol/groups/worktree";
 import { Effect } from "effect";
 import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
 import { Api } from "../api";
-export const WorktreeHandler = HttpApiBuilder.group(Api, "server.worktree", (handlers) => handlers.handle("worktree.list", () => run((worktrees) => worktrees.list())).handle("worktree.create", (ctx) => run((worktrees) => worktrees.create(ctx.payload))).handle("worktree.remove", (ctx) => run((worktrees) => worktrees.remove(ctx.payload)).pipe(Effect.as(HttpApiSchema.NoContent.make()))).handle("worktree.refresh", () => run((worktrees) => worktrees.refresh()).pipe(Effect.as(HttpApiSchema.NoContent.make()))));
-function run(action) {
-  return Effect.gen(function* () {
-    const plugins = yield* Plugin.Service, worktrees = yield* Worktree.Service;
-    yield* plugins.awaitActivation;
-    return yield* action(worktrees);
-  }).pipe(badRequest);
-}
+export const WorktreeHandler = HttpApiBuilder.group(Api, "server.worktree", (handlers) => Effect.gen(function* () {
+  const worktrees = yield* Worktree.Service;
+  return handlers.handle("worktree.list", (ctx) => worktrees.list(ctx.query).pipe(Effect.catchTag("Project.NotFoundError", missingProject))).handle("worktree.create", (ctx) => worktrees.create(ctx.payload).pipe(badRequest)).handle("worktree.remove", (ctx) => worktrees.remove(ctx.payload).pipe(badRequest, Effect.as(HttpApiSchema.NoContent.make()))).handle("worktree.refresh", (ctx) => worktrees.refresh(ctx.payload).pipe(badRequest, Effect.as(HttpApiSchema.NoContent.make())));
+}));
 function badRequest(effect) {
-  return effect.pipe(Effect.mapError((error) => new WorktreeError({
+  return effect.pipe(Effect.catchTag("Project.NotFoundError", missingProject), Effect.mapError((error) => error instanceof ProjectNotFoundError ? error : new WorktreeError({
     name: "WorktreeError",
     data: {
       message: message(error),
@@ -22,6 +19,9 @@ function badRequest(effect) {
     }
   })));
 }
+function missingProject(error) {
+  return Effect.fail(new ProjectNotFoundError({ projectID: error.projectID, message: `Project not found: ${error.projectID}` }));
+}
 function message(error) {
   if (error instanceof Worktree.SourceDirectoryNotFoundError)
     return error.directory ? `Worktree source not found: ${error.directory}` : `Worktree source not found for project: ${error.projectID}`;
@@ -33,7 +33,5 @@ function message(error) {
     return `Invalid worktree directory: ${error.directory}`;
   if (error instanceof Worktree.StrategyUnavailableError)
     return `Worktree strategy unavailable: ${error.strategy}`;
-  if (error instanceof Worktree.UnsupportedLocationError)
-    return "Worktree operations only support local locations";
   return error.message;
 }

package/dist/handlers.d.ts

@@ -1,2 +1,2 @@
 import { Layer } from "effect";
-export declare const handlers: Layer.Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.generate"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.message"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.model"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.provider"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.session"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.permission"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.fs"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.form"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.command"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.skill"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.rpc"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.event"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.agent"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.plugin"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.health"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.server"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.debug"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.pty"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.experimental"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.shell"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.reference"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.location"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.integration"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.websearch"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.mcp"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.credential"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.project"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.worktree"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.vcs"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.migration"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.config"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.workspace">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("@opencode/util/global").Service | import("@opencode/core/bus").Service | import("@opencode/core/workspace").Service | import("@opencode/core/persistent-pty/index").Service | import("@opencode/core/location-service-map").Service | import("@opencode/core/session").Service | import("@opencode/core/instance").Service | import("./location").LocationMiddleware | import("./middleware/form-location").FormLocationMiddleware | import("./middleware/session-location").SessionLocationMiddleware | import("@opencode/core/pty/ticket").Service | import("@opencode/core/session/transfer").Service | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/database/database").Service> | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/permission/saved").Service> | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/plugin/update").Service> | import("effect/unstable/http/HttpRouter").Request<"Requires", import("./server-info").Service> | import("./pty-environment").Service | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/wellknown").Service> | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/project").Service>>;
+export declare const handlers: Layer.Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.generate"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.message"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.model"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.provider"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.session"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.permission"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.fs"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.form"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.command"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.skill"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.rpc"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.event"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.agent"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.plugin"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.server"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.debug"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.pty"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.experimental"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.shell"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.reference"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.location"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.integration"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.websearch"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.mcp"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.credential"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.project"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.worktree"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.vcs"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.migration"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.config">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("@opencode/util/global").Service | import("@opencode/core/bus").Service | import("@opencode/core/persistent-pty/index").Service | import("@opencode/core/location-service-map").Service | import("@opencode/core/session").Service | import("@opencode/core/instance").Service | import("@opencode/core/worktree").Service | import("./location").LocationMiddleware | import("./middleware/form-location").FormLocationMiddleware | import("./middleware/session-location").SessionLocationMiddleware | import("@opencode/core/pty/ticket").Service | import("@opencode/core/session/transfer").Service | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/database/database").Service> | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/permission/saved").Service> | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/plugin/update").Service> | import("effect/unstable/http/HttpRouter").Request<"Requires", import("./server-info").Service> | import("./pty-environment").Service | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/wellknown").Service> | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/credential").Service> | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/project").Service>>;

package/dist/handlers.js

@@ -13,7 +13,6 @@ import { RpcHandler } from "./handlers/rpc";
 import { EventHandler } from "./handlers/event";
 import { AgentHandler } from "./handlers/agent";
 import { PluginHandler } from "./handlers/plugin";
-import { HealthHandler } from "./handlers/health";
 import { ServerHandler } from "./handlers/server";
 import { DebugHandler } from "./handlers/debug";
 import { PtyHandler } from "./handlers/pty";
@@ -31,5 +30,4 @@ import { VcsHandler } from "./handlers/vcs";
 import { EventFeed } from "./event-feed";
 import { MigrationHandler } from "./handlers/migration";
 import { ConfigHandler } from "./handlers/config";
-import { WorkspaceHandler } from "./handlers/workspace";
-export const handlers = Layer.mergeAll(HealthHandler, ServerHandler, DebugHandler, MigrationHandler, LocationHandler, AgentHandler, PluginHandler, SessionHandler, MessageHandler, ModelHandler, GenerateHandler, ProviderHandler, IntegrationHandler, WebSearchHandler, McpHandler, CredentialHandler, ProjectHandler, FormHandler, PermissionHandler, FileSystemHandler, CommandHandler, SkillHandler, RpcHandler, EventHandler.pipe(Layer.provide(EventFeed.layer)), PtyHandler, PersistentPtyHandler, ShellHandler, ReferenceHandler, WorktreeHandler, WorkspaceHandler, VcsHandler, ConfigHandler);
+export const handlers = Layer.mergeAll(ServerHandler, DebugHandler, MigrationHandler, LocationHandler, AgentHandler, PluginHandler, SessionHandler, MessageHandler, ModelHandler, GenerateHandler, ProviderHandler, IntegrationHandler, WebSearchHandler, McpHandler, CredentialHandler, ProjectHandler, FormHandler, PermissionHandler, FileSystemHandler, CommandHandler, SkillHandler, RpcHandler, EventHandler.pipe(Layer.provide(EventFeed.layer)), PtyHandler, PersistentPtyHandler, ShellHandler, ReferenceHandler, WorktreeHandler, VcsHandler, ConfigHandler);

package/dist/location.js

@@ -2,7 +2,6 @@ import { Location } from "@opencode/core/location";
 import { LocationServiceMap } from "@opencode/core/location-services";
 import { AbsolutePath } from "@opencode/core/schema";
 import { Session } from "@opencode/core/session";
-import { Workspace } from "@opencode/core/workspace";
 import { InvalidRequestError } from "@opencode/protocol/errors";
 import { Effect, Layer, Schema } from "effect";
 import { HttpServerRequest } from "effect/unstable/http";
@@ -17,7 +16,6 @@ export function response(data) {
     return {
       location: new Location.Info({
         directory: location.directory,
-        workspaceID: location.workspaceID,
         project: location.project
       }),
       data: yield* data
@@ -30,10 +28,9 @@ export const sessionInfo = Effect.fnUntraced(function* (sessions, sessionID) {
   return yield* sessions.get(id).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
 });
 export function requestRef(request) {
-  const query = new URL(request.url, "http://localhost").searchParams, workspaceID = query.get("location[workspace]") || request.headers["x-opencode-workspace"], directory = query.get("location[directory]") || (request.headers["x-opencode-directory"] ? decode(request.headers["x-opencode-directory"]) : process.cwd());
+  const directory = new URL(request.url, "http://localhost").searchParams.get("location[directory]") || (request.headers["x-opencode-directory"] ? decode(request.headers["x-opencode-directory"]) : process.cwd());
   return Location.Ref.make({
-    directory: AbsolutePath.make(directory),
-    workspaceID: workspaceID ? Workspace.ID.make(workspaceID) : void 0
+    directory: AbsolutePath.make(directory)
   });
 }
 function decode(input) {

package/dist/process.js

@@ -27,8 +27,14 @@ export const start = Effect.fn("ServerProcess.start")(function* (options, lifecy
   const password = options.password;
   if (!password)
     return yield* Effect.fail(Error("Missing server password"));
-  const hostname = options.hostname ?? "127.0.0.1", port = Option.fromNullishOr(options.port), shutdown = yield* Latch.make(), status = yield* Status.make(), bound = yield* listen({ hostname, port }), application = yield* Ref.make(Option.none());
-  yield* bound.http.serve(dispatch(password, status, application, options.app?.version ?? "unknown").pipe(HttpMiddleware.cors({ allowedOrigins: (origin) => isAllowedCorsOrigin(origin, options), maxAge: 86400 })), errorResponseLogger).pipe(withoutParentSpan);
+  const hostname = options.hostname ?? "127.0.0.1", port = Option.fromNullishOr(options.port), shutdown = yield* Latch.make(), status = yield* Status.make(), bound = yield* listen({ hostname, port }), urls = () => {
+    const address = bound.server.address();
+    if (address === null || typeof address === "string")
+      return [];
+    const host = address.family === "IPv6" ? `[${address.address}]` : address.address;
+    return ServerInfo.connectionURLs(`http://${host}:${address.port}`, hostname);
+  }, application = yield* Ref.make(Option.none());
+  yield* bound.http.serve(dispatch(password, status, application, options.app?.version ?? "unknown", urls).pipe(HttpMiddleware.cors({ allowedOrigins: (origin) => isAllowedCorsOrigin(origin, options), maxAge: 86400 })), errorResponseLogger).pipe(withoutParentSpan);
   if (lifecycle)
     yield* lifecycle.onListen(bound.http.address, shutdown.open.pipe(Effect.asVoid)).pipe(Effect.flatMap((cleanup) => Effect.addFinalizer(() => Scope.close(bound.scope, Exit.void).pipe(Effect.andThen(cleanup)))), Effect.uninterruptible);
   const parentScope = yield* Scope.Scope, applicationScope = yield* Scope.fork(parentScope);
@@ -37,13 +43,7 @@ export const start = Effect.fn("ServerProcess.start")(function* (options, lifecy
     const context = yield* Layer.buildWithScope(createRoutes({
       ...options,
       password
-    }, () => {
-      const address = bound.server.address();
-      if (address === null || typeof address === "string")
-        return [];
-      const host = address.family === "IPv6" ? `[${address.address}]` : address.address;
-      return ServerInfo.connectionURLs(`http://${host}:${address.port}`, hostname);
-    }).pipe(Layer.provideMerge(NodeHttpServer.layerHttpServices)), applicationScope);
+    }, urls).pipe(Layer.provideMerge(NodeHttpServer.layerHttpServices)), applicationScope);
     if (lifecycle)
       yield* installRestartContinuity(Context.get(context, SessionRestart.Service)).pipe(Effect.provideService(Scope.Scope, applicationScope));
     const app = Context.get(context, HttpRouter.HttpRouter).asHttpEffect().pipe(HttpMiddleware.compression(), Effect.provideService(HttpPlatform.HttpPlatform, Context.get(context, HttpPlatform.HttpPlatform)));
@@ -87,14 +87,14 @@ function addressInUse(error) {
   const cause = error.cause;
   return typeof cause === "object" && cause !== null && "code" in cause && cause.code === "EADDRINUSE";
 }
-function dispatch(password, status, application, version) {
+function dispatch(password, status, application, version, urls) {
   const auth = ServerAuth.Config.of({ password: Option.some(password), username: "opencode" });
   return Effect.gen(function* () {
     const request = yield* HttpServerRequest.HttpServerRequest, url = new URL(request.url, "http://localhost");
-    if (request.method === "GET" && url.pathname === "/api/health") {
+    if (request.method === "GET" && url.pathname === "/api/status") {
       if (!(yield* authorizedRequest(request, auth)))
         return unauthorized();
-      return yield* healthResponse(status, version);
+      return yield* statusResponse(status, version, urls);
     }
     const state = yield* status.current, app = yield* Ref.get(application), ready = state.type === "ready" && Option.isSome(app);
     if ((!ready || !hasPtyConnectTicketURL(url) && !hasPersistentPtyConnectTicketURL(url)) && !(yield* authorizedRequest(request, auth)))
@@ -110,9 +110,9 @@ function unauthorized() {
     headers: { "www-authenticate": 'Basic realm="Secure Area"' }
   });
 }
-const healthResponse = Effect.fnUntraced(function* (status, version) {
+const statusResponse = Effect.fnUntraced(function* (status, version, urls) {
   const state = yield* status.current;
-  return HttpServerResponse.jsonUnsafe({ healthy: !0, version, pid: process.pid }, {
+  return HttpServerResponse.jsonUnsafe({ version, pid: process.pid, urls: urls() }, {
     status: state.type === "ready" ? 200 : state.type === "failed" ? 500 : 503,
     headers: state.type === "starting" || state.type === "stopping" ? { "retry-after": "1" } : void 0
   });

package/dist/routes.d.ts

@@ -7,6 +7,7 @@ import { PermissionSaved } from "@opencode/core/permission/saved";
 import { PtyTicket } from "@opencode/core/pty/ticket";
 import { PersistentPty } from "@opencode/core/persistent-pty";
 import { Project } from "@opencode/core/project";
+import { Worktree } from "@opencode/core/worktree";
 import { Session } from "@opencode/core/session";
 import { Instance } from "@opencode/core/instance/service";
 import { SessionTransfer } from "@opencode/core/session/transfer";
@@ -23,7 +24,7 @@ import { HttpRouter } from "effect/unstable/http";
 import { Layer } from "effect";
 import { PtyEnvironment } from "./pty-environment";
 import type { ServerOptions } from "./options";
-export declare function createRoutes(options?: ServerOptions, serviceURLs?: () => ReadonlyArray<string>, overrides?: LayerNode.Replacements): Layer.Layer<Global.Service | Database.Service | Bus.Service | import("effect/unstable/http/HttpClient").HttpClient | Project.Service | Credential.Service | WellKnown.Service | Workspace.Service | PermissionSaved.Service | PersistentPty.Service | LocationServiceMap.Service | SdkPlugins.Service | PluginUpdate.Service | Session.Service | Job.Service | Instance.Service | SessionRestart.Service | PtyTicket.Service | SessionTransfer.Service | LocationActivity.Service | PtyEnvironment.Service | HttpRouter.HttpRouter, Error | PersistentPty.UnavailableError, import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("effect/unstable/http/Etag").Generator | import("effect/unstable/http/HttpPlatform").HttpPlatform>;
+export declare function createRoutes(options?: ServerOptions, serviceURLs?: () => ReadonlyArray<string>, overrides?: LayerNode.Replacements): Layer.Layer<Global.Service | Database.Service | Bus.Service | import("effect/unstable/http/HttpClient").HttpClient | Project.Service | Credential.Service | WellKnown.Service | Workspace.Service | PermissionSaved.Service | PersistentPty.Service | LocationServiceMap.Service | SdkPlugins.Service | PluginUpdate.Service | Session.Service | Job.Service | Instance.Service | Worktree.Service | SessionRestart.Service | PtyTicket.Service | SessionTransfer.Service | LocationActivity.Service | PtyEnvironment.Service | HttpRouter.HttpRouter, Error | PersistentPty.UnavailableError, import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("effect/unstable/http/Etag").Generator | import("effect/unstable/http/HttpPlatform").HttpPlatform>;
 type InstanceNode = (replacements: () => LayerNode.Replacements) => LayerNode.Provider<Instance.Service, never, typeof Node.tags.values.global>;
-export declare function createEmbeddedRoutes(options?: ServerOptions, overrides?: LayerNode.Replacements, instances?: InstanceNode): Layer.Layer<Global.Service | Database.Service | Bus.Service | import("effect/unstable/http/HttpClient").HttpClient | Project.Service | Credential.Service | WellKnown.Service | Workspace.Service | PermissionSaved.Service | PersistentPty.Service | LocationServiceMap.Service | SdkPlugins.Service | PluginUpdate.Service | Session.Service | Job.Service | Instance.Service | SessionRestart.Service | PtyTicket.Service | SessionTransfer.Service | LocationActivity.Service | PtyEnvironment.Service | HttpRouter.HttpRouter, Error | PersistentPty.UnavailableError, import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("effect/unstable/http/Etag").Generator | import("effect/unstable/http/HttpPlatform").HttpPlatform>;
+export declare function createEmbeddedRoutes(options?: ServerOptions, overrides?: LayerNode.Replacements, instances?: InstanceNode): Layer.Layer<Global.Service | Database.Service | Bus.Service | import("effect/unstable/http/HttpClient").HttpClient | Project.Service | Credential.Service | WellKnown.Service | Workspace.Service | PermissionSaved.Service | PersistentPty.Service | LocationServiceMap.Service | SdkPlugins.Service | PluginUpdate.Service | Session.Service | Job.Service | Instance.Service | Worktree.Service | SessionRestart.Service | PtyTicket.Service | SessionTransfer.Service | LocationActivity.Service | PtyEnvironment.Service | HttpRouter.HttpRouter, Error | PersistentPty.UnavailableError, import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("effect/unstable/http/Etag").Generator | import("effect/unstable/http/HttpPlatform").HttpPlatform>;
 export {};

package/dist/routes.js

@@ -14,6 +14,7 @@ import { PermissionSaved } from "@opencode/core/permission/saved";
 import { PtyTicket } from "@opencode/core/pty/ticket";
 import { PersistentPty } from "@opencode/core/persistent-pty";
 import { Project } from "@opencode/core/project";
+import { Worktree } from "@opencode/core/worktree";
 import { Session } from "@opencode/core/session";
 import { Instance } from "@opencode/core/instance/service";
 import { SessionTransfer } from "@opencode/core/session/transfer";
@@ -53,6 +54,7 @@ const applicationServiceNodes = [
   httpClient,
   Job.node,
   Project.node,
+  Worktree.node,
   Session.node,
   Instance.node,
   SessionTransfer.node,
@@ -110,7 +112,7 @@ function makeRoutes(auth, options, serviceURLs, overrides, instances) {
     const { simulationReplacements } = yield* Effect.promise(() => import("@opencode/simulation/backend")), simulation = yield* simulationReplacements({ version: App.make(options.app).version });
     return build([...overrides, ...simulation]);
   })) : build(overrides)).pipe(Layer.flatMap((context) => {
-    const services = Layer.succeedContext(context), requestServices = Layer.merge(Layer.succeedContext(Context.pick(Database.Service, PermissionSaved.Service, PluginUpdate.Service, Project.Service, WellKnown.Service)(context)), ServerInfo.layer(serviceURLs, options.app)), api = HttpApiBuilder.layer(Api, { openapiPath: "/openapi.json" }).pipe(Layer.provide(handlers.pipe(Layer.provide(services), Layer.provide(Layer.succeed(CorsConfig, options)))), Layer.provide(formLocationLayer), Layer.provide(sessionLocationLayer), Layer.provide(layer), Layer.provide(authorizationLayer), Layer.provide(schemaErrorLayer), Layer.provide(auth), HttpRouter.provideRequest(requestServices), Layer.provideMerge(services), Layer.provideMerge(HttpRouter.layer));
+    const services = Layer.succeedContext(context), requestServices = Layer.merge(Layer.succeedContext(Context.pick(Database.Service, Credential.Service, PermissionSaved.Service, PluginUpdate.Service, Project.Service, WellKnown.Service)(context)), ServerInfo.layer(serviceURLs, options.app)), api = HttpApiBuilder.layer(Api, { openapiPath: "/openapi.json" }).pipe(Layer.provide(handlers.pipe(Layer.provide(services), Layer.provide(Layer.succeed(CorsConfig, options)))), Layer.provide(formLocationLayer), Layer.provide(sessionLocationLayer), Layer.provide(layer), Layer.provide(authorizationLayer), Layer.provide(schemaErrorLayer), Layer.provide(auth), HttpRouter.provideRequest(requestServices), Layer.provideMerge(services), Layer.provideMerge(HttpRouter.layer));
     return Layer.merge(api, V1Migration.layer.pipe(Layer.provide(services)));
   }));
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/server",
-  "version": "2.0.3",
+  "version": "2.0.5",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -30,17 +30,17 @@
   "dependencies": {
     "@effect/platform-node": "4.0.0-rc.112",
     "@effect/platform-node-shared": "4.0.0-rc.112",
-    "@opencode/core": "2.0.3",
-    "@opencode/protocol": "2.0.3",
-    "@opencode/schema": "2.0.3",
-    "@opencode/simulation": "2.0.3",
-    "@opencode/util": "2.0.3",
+    "@opencode/core": "2.0.5",
+    "@opencode/protocol": "2.0.5",
+    "@opencode/schema": "2.0.5",
+    "@opencode/simulation": "2.0.5",
+    "@opencode/util": "2.0.5",
     "drizzle-orm": "1.0.0-rc.5-169397b",
     "effect": "4.0.0-rc.112"
   },
   "devDependencies": {
-    "@opencode/client": "2.0.3",
-    "@opencode/plugin": "2.0.3",
+    "@opencode/client": "2.0.5",
+    "@opencode/plugin": "2.0.5",
     "@tsconfig/bun": "1.0.9",
     "@types/bun": "1.4.0",
     "@typescript/native-preview": "7.0.0-dev.20251207.1"

package/dist/handlers/health.d.ts

@@ -1,2 +0,0 @@
-import { ServerInfo } from "../server-info";
-export declare const HealthHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.health">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("effect/unstable/http/HttpRouter").Request<"Requires", ServerInfo.Service>>;

package/dist/handlers/health.js

@@ -1,11 +0,0 @@
-import { Effect } from "effect";
-import { HttpApiBuilder } from "effect/unstable/httpapi";
-import { Api } from "../api";
-import { ServerInfo } from "../server-info";
-export const HealthHandler = HttpApiBuilder.group(Api, "server.health", (handlers) => handlers.handle("health.get", () => Effect.gen(function* () {
-  return {
-    healthy: !0,
-    version: (yield* ServerInfo.Service).app.version ?? "unknown",
-    pid: process.pid ?? 0
-  };
-})));

package/dist/handlers/workspace.d.ts

@@ -1,2 +0,0 @@
-import { Workspace } from "@opencode/core/workspace";
-export declare const WorkspaceHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.workspace">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | Workspace.Service>;

package/dist/handlers/workspace.js

@@ -1,20 +0,0 @@
-import { Workspace } from "@opencode/core/workspace";
-import { ConflictError, ProviderNotFoundError, UnknownError } from "@opencode/protocol/errors";
-import { Effect } from "effect";
-import { HttpApiBuilder } from "effect/unstable/httpapi";
-import { Api } from "../api";
-export const WorkspaceHandler = HttpApiBuilder.group(Api, "server.workspace", (handlers) => Effect.gen(function* () {
-  const workspace = yield* Workspace.Service;
-  return handlers.handle("workspace.create", (ctx) => workspace.create(ctx.payload).pipe(Effect.map((workspaceID) => ({ data: workspaceID })), Effect.catchTags({
-    "Workspace.CreateConflict": (error) => new ConflictError({
-      resource: error.workspaceID,
-      message: `Workspace ${error.workspaceID} already uses provider ${error.existingProvider}, not ${error.provider}`
-    }),
-    "WorkspaceDriver.ProviderNotFound": (error) => new ProviderNotFoundError({
-      providerID: error.provider,
-      message: `Workspace provider not found: ${error.provider}`
-    })
-  }))).handle("workspace.destroy", (ctx) => workspace.destroy(ctx.params.workspaceID).pipe(Effect.mapError((error) => new UnknownError({
-    message: error._tag === "WorkspaceDriver.ProviderNotFound" ? `Workspace provider not found: ${error.provider}` : error.message ?? "Workspace provider failed to destroy the workspace"
-  }))));
-}));