@opencode/protocol 2.0.2 → 2.0.4

package/dist/groups/shell.d.ts

@@ -1,14 +1,14 @@
-import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
 import { ShellNotFoundError } from "../errors.js";
 export declare const ShellGroup: HttpApiGroup.HttpApiGroup<"server.shell", HttpApiEndpoint.HttpApiEndpoint<"shell.list", "GET", "/api/shell", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
     }>>;
 }>>, never, never, Schema.toCodecJson<Schema.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.$Array<Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Shell.ID">;
@@ -30,15 +30,16 @@ export declare const ShellGroup: HttpApiGroup.HttpApiGroup<"server.shell", HttpA
 }>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.create", "POST", "/api/shell", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
     }>>;
 }>>, Schema.toCodecJson<Schema.Struct<{
     readonly command: Schema.String;
     readonly cwd: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-    readonly timeout: Schema.Int;
+    readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
     readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Shell.ID">;
@@ -65,42 +66,11 @@ export declare const ShellGroup: HttpApiGroup.HttpApiGroup<"server.shell", HttpA
 }>>, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
     }>>;
 }>>, never, never, Schema.toCodecJson<Schema.Struct<{
-    readonly location: typeof Location.Info;
-    readonly data: Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
-            create: () => string & import("effect/Brand").Brand<"Shell.ID">;
-            ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
-        };
-        readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
-        readonly command: Schema.String;
-        readonly cwd: Schema.String;
-        readonly shell: Schema.String;
-        readonly file: Schema.String;
-        readonly pid: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
-        readonly exit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
-        readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
-        readonly time: Schema.Struct<{
-            readonly started: Schema.Finite;
-            readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
-        }>;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
     }>;
-}>>, Schema.toCodecJson<typeof ShellNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"shell.timeout", "PATCH", "/api/shell/:id/timeout", Schema.toCodecStringTree<Schema.Struct<{
-    id: Schema.brand<Schema.String, "Shell.ID"> & {
-        create: () => string & import("effect/Brand").Brand<"Shell.ID">;
-        ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
-    };
-}>>, Schema.toCodecStringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
-    }>>;
-}>>, Schema.toCodecJson<Schema.Struct<{
-    readonly timeout: Schema.Int;
-}>>, never, Schema.toCodecJson<Schema.Struct<{
-    readonly location: typeof Location.Info;
     readonly data: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Shell.ID">;
@@ -129,10 +99,11 @@ export declare const ShellGroup: HttpApiGroup.HttpApiGroup<"server.shell", HttpA
     readonly limit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
     }>>;
 }>>, never, never, Schema.toCodecJson<Schema.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.Struct<{
         readonly output: Schema.String;
         readonly cursor: Schema.Int;
@@ -147,6 +118,5 @@ export declare const ShellGroup: HttpApiGroup.HttpApiGroup<"server.shell", HttpA
 }>>, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
     }>>;
-}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof ShellNotFoundError>, never, never>, false>;
+}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, never, never, never>, false>;

package/dist/groups/shell.js

@@ -1,13 +1,9 @@
 import { Shell } from "@opencode/schema/shell";
 import { Location } from "@opencode/schema/location";
-import { NonNegativeInt } from "@opencode/schema/schema";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
 import { ShellNotFoundError } from "../errors.js";
 import { LocationQuery, locationQueryOpenApi } from "./location.js";
-const TimeoutInput = Schema.Struct({
-    timeout: NonNegativeInt,
-});
 export const ShellGroup = HttpApiGroup.make("server.shell")
     .add(HttpApiEndpoint.get("shell.list", "/api/shell", {
     query: LocationQuery,
@@ -15,7 +11,7 @@ export const ShellGroup = HttpApiGroup.make("server.shell")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.shell.list",
+    identifier: "shell.list",
     summary: "List running shell commands",
     description: "List currently running shell commands for a location. Exited commands are not included.",
 })))
@@ -26,7 +22,7 @@ export const ShellGroup = HttpApiGroup.make("server.shell")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.shell.create",
+    identifier: "shell.create",
     summary: "Run shell command",
     description: "Spawn one non-interactive shell command for a location. Combined stdout/stderr is captured to a file pageable via output.",
 })))
@@ -38,22 +34,9 @@ export const ShellGroup = HttpApiGroup.make("server.shell")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.shell.get",
+    identifier: "shell.get",
     summary: "Get shell command",
     description: "Get one shell command, including its status and exit code once exited.",
-})))
-    .add(HttpApiEndpoint.patch("shell.timeout", "/api/shell/:id/timeout", {
-    params: { id: Shell.ID },
-    query: LocationQuery,
-    payload: TimeoutInput,
-    success: Location.response(Shell.Info),
-    error: ShellNotFoundError,
-})
-    .annotateMerge(locationQueryOpenApi)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.shell.timeout",
-    summary: "Update shell timeout",
-    description: "Replace a running shell command's timeout from now, or clear it with zero.",
 })))
     .add(HttpApiEndpoint.get("shell.output", "/api/shell/:id/output", {
     params: { id: Shell.ID },
@@ -63,7 +46,7 @@ export const ShellGroup = HttpApiGroup.make("server.shell")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.shell.output",
+    identifier: "shell.output",
     summary: "Read shell output",
     description: "Page through captured combined output by absolute byte cursor.",
 })))
@@ -71,12 +54,11 @@ export const ShellGroup = HttpApiGroup.make("server.shell")
     params: { id: Shell.ID },
     query: LocationQuery,
     success: HttpApiSchema.NoContent,
-    error: ShellNotFoundError,
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.shell.remove",
+    identifier: "shell.remove",
     summary: "Remove shell command",
     description: "Terminate and remove one shell command and its retained output.",
 })))
-    .annotateMerge(OpenApi.annotations({ title: "shell", description: "Experimental location-scoped shell command routes." }));
+    .annotateMerge(OpenApi.annotations({ title: "shell", description: "Location-scoped shell command routes." }));

package/dist/groups/skill.d.ts

@@ -1,20 +1,19 @@
-import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
 export declare const SkillGroup: HttpApiGroup.HttpApiGroup<"server.skill", HttpApiEndpoint.HttpApiEndpoint<"skill.list", "GET", "/api/skill", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
     }>>;
 }>>, never, never, Schema.toCodecJson<Schema.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.$Array<Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Skill.ID">;
         readonly name: Schema.brand<Schema.String, "Skill.Name">;
         readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly slash: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly autoinvoke: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-        readonly location: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly path: Schema.brand<Schema.String, "AbsolutePath">;
         readonly content: Schema.String;
     }>>;
 }>>, never, never, never>, false>;

package/dist/groups/skill.js

@@ -10,7 +10,7 @@ export const SkillGroup = HttpApiGroup.make("server.skill")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.skill.list",
+    identifier: "skill.list",
     summary: "List skills",
     description: "Retrieve currently registered skills.",
 })))

package/dist/groups/vcs.d.ts

@@ -1,15 +1,16 @@
-import { Location } from "@opencode/schema/location";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
 import { ServiceUnavailableError } from "../errors.js";
 export declare const VcsGroup: HttpApiGroup.HttpApiGroup<"server.vcs", HttpApiEndpoint.HttpApiEndpoint<"vcs.get", "GET", "/api/vcs", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
     }>>;
 }>>, never, never, Schema.toCodecJson<Schema.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.Struct<{
+        readonly provider: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly branch: Schema.Struct<{
             readonly current: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
             readonly default: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
@@ -18,10 +19,11 @@ export declare const VcsGroup: HttpApiGroup.HttpApiGroup<"server.vcs", HttpApiEn
 }>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"vcs.base", "GET", "/api/vcs/base", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
     }>>;
 }>>, never, never, Schema.toCodecJson<Schema.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.NullOr<Schema.Struct<{
         readonly name: Schema.String;
         readonly ref: Schema.String;
@@ -30,25 +32,27 @@ export declare const VcsGroup: HttpApiGroup.HttpApiGroup<"server.vcs", HttpApiEn
 }>>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"vcs.status", "GET", "/api/vcs/status", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
     }>>;
 }>>, never, never, Schema.toCodecJson<Schema.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.$Array<Schema.Struct<{
         readonly file: Schema.String;
         readonly additions: Schema.Int;
         readonly deletions: Schema.Int;
         readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
     }>>;
-}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"vcs.branches", "GET", "/api/vcs/branches", never, Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"vcs.branch.list", "GET", "/api/vcs/branch", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly search: Schema.optional<Schema.String>;
     readonly limit: Schema.optional<Schema.compose<Schema.Int, Schema.NumberFromString>>;
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
     }>>;
 }>>, never, never, Schema.toCodecJson<Schema.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.$Array<Schema.String>;
 }>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"vcs.diff", "GET", "/api/vcs/diff", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly mode: Schema.Literals<readonly ["working", "branch", "committed"]>;
@@ -56,10 +60,11 @@ export declare const VcsGroup: HttpApiGroup.HttpApiGroup<"server.vcs", HttpApiEn
     readonly context: Schema.optional<Schema.compose<Schema.Int, Schema.NumberFromString>>;
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
     }>>;
 }>>, never, never, Schema.toCodecJson<Schema.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.$Array<Schema.Struct<{
         readonly file: Schema.String;
         readonly patch: Schema.String;

package/dist/groups/vcs.js

@@ -24,7 +24,7 @@ export const VcsGroup = HttpApiGroup.make("server.vcs")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.vcs.get",
+    identifier: "vcs.get",
     summary: "VCS info",
     description: "Get current and default branch information for the requested location.",
 })))
@@ -35,7 +35,7 @@ export const VcsGroup = HttpApiGroup.make("server.vcs")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.vcs.base",
+    identifier: "vcs.base",
     summary: "VCS review base",
     description: "Infer a local review base from named branch creation history, or the repository default only when currently on that branch. Returns null before the first commit or when the provider lacks base metadata; ambiguous Git history requires an explicit base on diff requests.",
 })))
@@ -45,17 +45,17 @@ export const VcsGroup = HttpApiGroup.make("server.vcs")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.vcs.status",
+    identifier: "vcs.status",
     summary: "VCS status",
     description: "List uncommitted working-copy changes relative to the requested location.",
 })))
-    .add(HttpApiEndpoint.get("vcs.branches", "/api/vcs/branches", {
+    .add(HttpApiEndpoint.get("vcs.branch.list", "/api/vcs/branch", {
     query: BranchesQuery,
     success: Location.response(Vcs.BranchList),
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.vcs.branches",
+    identifier: "vcs.branch.list",
     summary: "VCS branches",
     description: "List local and remote branches available at the requested location.",
 })))
@@ -66,7 +66,7 @@ export const VcsGroup = HttpApiGroup.make("server.vcs")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.vcs.diff",
+    identifier: "vcs.diff",
     summary: "VCS diff",
     description: "Diff HEAD to the working copy (working), the base merge-base to the working copy (branch), or the base merge-base to HEAD (committed). Omitting base preserves repository-default comparison; supplying it overrides the comparison without saving it.",
 })))

package/dist/groups/websearch.d.ts

@@ -1,4 +1,3 @@
-import { Location } from "@opencode/schema/location";
 import { WebSearch } from "@opencode/schema/websearch";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
@@ -6,10 +5,11 @@ import { InvalidRequestError, ServiceUnavailableError } from "../errors.js";
 export declare const WebSearchGroup: HttpApiGroup.HttpApiGroup<"server.websearch", HttpApiEndpoint.HttpApiEndpoint<"websearch.providers", "GET", "/api/websearch/provider", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
     }>>;
 }>>, never, never, Schema.toCodecJson<Schema.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: Schema.$Array<Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "WebSearch.ID">;
         readonly name: Schema.String;
@@ -17,12 +17,13 @@ export declare const WebSearchGroup: HttpApiGroup.HttpApiGroup<"server.websearch
 }>>, Schema.toCodecJson<typeof ServiceUnavailableError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"websearch.query", "POST", "/api/websearch", never, Schema.toCodecStringTree<Schema.Struct<{
     readonly location: Schema.optional<Schema.Struct<{
         readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
     }>>;
 }>>, Schema.toCodecJson<Schema.Struct<{
     readonly query: Schema.String;
     readonly providerID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WebSearch.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "WebSearch.ID">>, never, never>;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
-    readonly location: typeof Location.Info;
+    readonly location: Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    }>;
     readonly data: typeof WebSearch.Response;
 }>>, Schema.toCodecJson<typeof InvalidRequestError | typeof ServiceUnavailableError>, never, never>, false>;

package/dist/groups/websearch.js

@@ -12,7 +12,7 @@ export const WebSearchGroup = HttpApiGroup.make("server.websearch")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.websearch.providers",
+    identifier: "websearch.providers",
     summary: "List web search providers",
     description: "Return the registered web search providers.",
 })))
@@ -24,7 +24,7 @@ export const WebSearchGroup = HttpApiGroup.make("server.websearch")
 })
     .annotateMerge(locationQueryOpenApi)
     .annotateMerge(OpenApi.annotations({
-    identifier: "v2.websearch.query",
+    identifier: "websearch.query",
     summary: "Search the web",
     description: "Run one web search through the selected provider. Specify a provider to override the configured default.",
 })))

package/dist/groups/worktree.d.ts

@@ -1,5 +1,6 @@
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi";
+import { ProjectNotFoundError } from "../errors.js";
 declare const WorktreeError_base: Schema.Class<WorktreeError, Schema.Struct<{
     readonly name: Schema.Literal<"WorktreeError">;
     readonly data: Schema.Struct<{
@@ -10,38 +11,31 @@ declare const WorktreeError_base: Schema.Class<WorktreeError, Schema.Struct<{
 export declare class WorktreeError extends WorktreeError_base {
 }
 export declare const WorktreeGroup: HttpApiGroup.HttpApiGroup<"server.worktree", HttpApiEndpoint.HttpApiEndpoint<"worktree.list", "GET", "/api/worktree", never, Schema.toCodecStringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
-    }>>;
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
 }>>, never, never, Schema.toCodecJson<Schema.$Array<Schema.Struct<{
     readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
     readonly strategy: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-}>>>, Schema.toCodecJson<typeof WorktreeError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.create", "POST", "/api/worktree", never, Schema.toCodecStringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
-    }>>;
-}>>, Schema.toCodecJson<Schema.Struct<{
-    readonly strategy: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Trim, "Worktree.StrategyID">>>, Schema.optionalKey<Schema.brand<Schema.Trim, "Worktree.StrategyID">>, never, never>;
+}>>>, Schema.toCodecJson<typeof ProjectNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.create", "POST", "/api/worktree", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
     readonly from: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "AbsolutePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "AbsolutePath">>, never, never>;
     readonly branch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Trim>>, Schema.optionalKey<Schema.Trim>, never, never>;
     readonly directory: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "AbsolutePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "AbsolutePath">>, never, never>;
     readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
     readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-}>>, Schema.toCodecJson<typeof WorktreeError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.remove", "DELETE", "/api/worktree", never, Schema.toCodecStringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
-    }>>;
-}>>, Schema.toCodecJson<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof ProjectNotFoundError | typeof WorktreeError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.remove", "DELETE", "/api/worktree", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
     readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
     readonly force: Schema.Boolean;
-}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof WorktreeError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.refresh", "POST", "/api/worktree/refresh", never, Schema.toCodecStringTree<Schema.Struct<{
-    readonly location: Schema.optional<Schema.Struct<{
-        readonly directory: Schema.optional<Schema.String>;
-        readonly workspace: Schema.optional<Schema.String>;
-    }>>;
-}>>, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof WorktreeError>, never, never>, false>;
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof ProjectNotFoundError | typeof WorktreeError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"worktree.refresh", "POST", "/api/worktree/refresh", never, never, Schema.toCodecJson<Schema.Struct<{
+    readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+}>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof ProjectNotFoundError | typeof WorktreeError>, never, never>, false>;
 export {};

package/dist/groups/worktree.js

@@ -1,7 +1,8 @@
 import { Worktree } from "@opencode/schema/worktree";
 import { Schema } from "effect";
 import { HttpApiEndpoint, HttpApiGroup, HttpApiSchema, OpenApi } from "effect/unstable/httpapi";
-import { LocationQuery, locationQueryOpenApi } from "./location.js";
+import { Project } from "@opencode/schema/project";
+import { ProjectNotFoundError } from "../errors.js";
 const root = "/api/worktree";
 export class WorktreeError extends Schema.Error("WorktreeError")({
     name: Schema.Literal("WorktreeError"),
@@ -13,49 +14,39 @@ export class WorktreeError extends Schema.Error("WorktreeError")({
 }
 export const WorktreeGroup = HttpApiGroup.make("server.worktree")
     .add(HttpApiEndpoint.get("worktree.list", root, {
-    query: LocationQuery,
+    query: Schema.Struct({ projectID: Project.ID }),
     success: Worktree.List,
-    error: WorktreeError,
-})
-    .annotateMerge(locationQueryOpenApi)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.worktree.list",
+    error: ProjectNotFoundError,
+}).annotateMerge(OpenApi.annotations({
+    identifier: "worktree.list",
     summary: "List worktrees",
-    description: "Discover worktrees through the requested location's strategies and return its project's inventory.",
+    description: "Return the project's saved worktree inventory without loading configuration or running discovery.",
 })))
     .add(HttpApiEndpoint.post("worktree.create", root, {
-    query: LocationQuery,
     payload: Worktree.CreateInput,
     success: Worktree.Info,
-    error: WorktreeError,
-})
-    .annotateMerge(locationQueryOpenApi)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.worktree.create",
+    error: [WorktreeError, ProjectNotFoundError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "worktree.create",
     summary: "Create worktree",
-    description: "Create a local worktree using the location's registered strategy and directory defaults, then run the project's setup script.",
+    description: "Load the project's canonical configuration, create a local worktree using its selected strategy, then run the project's setup script.",
 })))
     .add(HttpApiEndpoint.delete("worktree.remove", root, {
-    query: LocationQuery,
     payload: Worktree.RemoveInput,
     success: HttpApiSchema.NoContent,
-    error: WorktreeError,
-})
-    .annotateMerge(locationQueryOpenApi)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.worktree.remove",
+    error: [WorktreeError, ProjectNotFoundError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "worktree.remove",
     summary: "Remove worktree",
-    description: "Remove a managed worktree from the requested location's project using its recorded strategy.",
+    description: "Load the project's canonical configuration and remove a saved worktree using its recorded strategy.",
 })))
     .add(HttpApiEndpoint.post("worktree.refresh", `${root}/refresh`, {
-    query: LocationQuery,
+    payload: Schema.Struct({ projectID: Project.ID }),
     success: HttpApiSchema.NoContent,
-    error: WorktreeError,
-})
-    .annotateMerge(locationQueryOpenApi)
-    .annotateMerge(OpenApi.annotations({
-    identifier: "v2.worktree.refresh",
+    error: [WorktreeError, ProjectNotFoundError],
+}).annotateMerge(OpenApi.annotations({
+    identifier: "worktree.refresh",
     summary: "Refresh worktrees",
-    description: "Discover worktrees from the requested location and reconcile the shared project inventory.",
+    description: "Load the project's canonical configuration, discover worktrees across known checkout roots using all available strategies, and reconcile saved state.",
 })))
-    .annotateMerge(OpenApi.annotations({ title: "worktree", description: "Location-scoped worktree management routes." }));
+    .annotateMerge(OpenApi.annotations({ title: "worktree", description: "Project-based worktree management routes." }));

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/protocol",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -32,7 +32,7 @@
     "typecheck": "tsgo --noEmit"
   },
   "dependencies": {
-    "@opencode/schema": "2.0.2",
+    "@opencode/schema": "2.0.4",
     "effect": "4.0.0-rc.112"
   },
   "devDependencies": {

package/dist/groups/health.d.ts

@@ -1,15 +0,0 @@
-import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
-export declare namespace ServiceStatus {
-    const Health: Schema.Struct<{
-        readonly healthy: Schema.Literal<true>;
-        readonly version: Schema.String;
-        readonly pid: Schema.Int;
-    }>;
-    type Health = typeof Health.Type;
-}
-export declare const HealthGroup: HttpApiGroup.HttpApiGroup<"server.health", HttpApiEndpoint.HttpApiEndpoint<"health.get", "GET", "/api/health", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
-    readonly healthy: Schema.Literal<true>;
-    readonly version: Schema.String;
-    readonly pid: Schema.Int;
-}>>, never, never, never>, false>;

package/dist/groups/health.js

@@ -1,20 +0,0 @@
-import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi";
-export var ServiceStatus;
-(function (ServiceStatus) {
-    ServiceStatus.Health = Schema.Struct({
-        healthy: Schema.Literal(true),
-        version: Schema.String,
-        // 0 means the runtime has no OS process identity (e.g. workerd).
-        pid: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
-    }).annotate({ identifier: "ServiceHealth" });
-})(ServiceStatus || (ServiceStatus = {}));
-export const HealthGroup = HttpApiGroup.make("server.health")
-    .add(HttpApiEndpoint.get("health.get", "/api/health", {
-    success: ServiceStatus.Health,
-}).annotateMerge(OpenApi.annotations({
-    identifier: "v2.health.get",
-    summary: "Check server health",
-    description: "Report the owning server process and its application status.",
-})))
-    .annotateMerge(OpenApi.annotations({ title: "health" }));

package/dist/groups/workspace.d.ts

@@ -1,22 +0,0 @@
-import { Schema } from "effect";
-import { HttpApiEndpoint, HttpApiGroup } from "effect/unstable/httpapi";
-import { ConflictError, ProviderNotFoundError, UnknownError } from "../errors.js";
-export declare const WorkspaceGroup: HttpApiGroup.HttpApiGroup<"server.workspace", HttpApiEndpoint.HttpApiEndpoint<"workspace.create", "POST", "/api/workspace", never, never, Schema.toCodecJson<Schema.Struct<{
-    readonly id: Schema.optional<Schema.brand<Schema.String, "Workspace.ID"> & {
-        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-    }>;
-    readonly provider: Schema.String;
-}>>, never, Schema.toCodecJson<Schema.Struct<{
-    readonly data: Schema.brand<Schema.String, "Workspace.ID"> & {
-        ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
-        create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
-    };
-}>>, Schema.toCodecJson<typeof ConflictError | typeof ProviderNotFoundError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"workspace.destroy", "DELETE", "/api/workspace/:workspaceID", Schema.toCodecStringTree<Schema.Struct<{
-    workspaceID: Schema.brand<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, Schema.toCodecJson<Schema.Struct<{
-    readonly destroyed: Schema.Boolean;
-}>>, Schema.toCodecJson<typeof UnknownError>, never, never>, false>;