@opencode/core 2.0.3 → 2.0.5

package/dist/types/session/session.d.ts

@@ -3,7 +3,6 @@ import { DateTime, Effect, Scope } from "effect";
 import type { Agent } from "@opencode/schema/agent";
 import type { Model } from "@opencode/schema/model";
 import type { Permission } from "@opencode/schema/permission";
-import { Event } from "@opencode/schema/event";
 import { FSUtil } from "@opencode/util/fs-util";
 import { Bus } from "../bus.js";
 import { Database } from "../database/database.js";
@@ -90,7 +89,9 @@ export declare const make: () => Effect.Effect<{
             readonly delivery: "steer" | "queue";
             readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
             readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-            readonly timeCreated: DateTime.Utc;
+            readonly time: {
+                readonly created: DateTime.Utc;
+            };
         } | {
             readonly type: "synthetic";
             readonly payload: {
@@ -103,14 +104,18 @@ export declare const make: () => Effect.Effect<{
             readonly delivery: "steer" | "queue";
             readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
             readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-            readonly timeCreated: DateTime.Utc;
+            readonly time: {
+                readonly created: DateTime.Utc;
+            };
         } | {
             readonly type: "compaction";
             readonly payload: {};
             readonly delivery: "steer" | "queue";
             readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
             readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-            readonly timeCreated: DateTime.Utc;
+            readonly time: {
+                readonly created: DateTime.Utc;
+            };
         } | {
             readonly type: "move";
             readonly payload: {
@@ -124,7 +129,9 @@ export declare const make: () => Effect.Effect<{
             readonly delivery: "steer" | "queue";
             readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
             readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-            readonly timeCreated: DateTime.Utc;
+            readonly time: {
+                readonly created: DateTime.Utc;
+            };
         })[], NotFoundError, never>;
         prompt: (input: PromptRequest) => Effect.Effect<{
             readonly type: "user";
@@ -172,7 +179,9 @@ export declare const make: () => Effect.Effect<{
             readonly delivery: "steer" | "queue";
             readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
             readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-            readonly timeCreated: DateTime.Utc;
+            readonly time: {
+                readonly created: DateTime.Utc;
+            };
         }, NotFoundError | PromptConflictError | import("./error.js").AttachmentError | import("./error.js").SkillNotFoundError, never>;
         synthetic: (input: {
             id?: SessionMessage.ID;
@@ -193,14 +202,16 @@ export declare const make: () => Effect.Effect<{
             readonly delivery: "steer" | "queue";
             readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
             readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-            readonly timeCreated: DateTime.Utc;
+            readonly time: {
+                readonly created: DateTime.Utc;
+            };
         }, NotFoundError | SyntheticConflictError, never>;
         shell: (input: {
-            id?: Event.ID;
+            id?: SessionMessage.ID;
             command: string;
         }) => Effect.Effect<void, NotFoundError, never>;
         skill: (input: {
-            id?: SessionMessage.ID;
+            messageID?: SessionMessage.ID;
             skill: Skill.ID;
             resume?: boolean;
         }) => Effect.Effect<void, NotFoundError | import("./error.js").SkillNotFoundError, never>;
@@ -213,12 +224,14 @@ export declare const make: () => Effect.Effect<{
             readonly delivery: "steer" | "queue";
             readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
             readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
-            readonly timeCreated: DateTime.Utc;
+            readonly time: {
+                readonly created: DateTime.Utc;
+            };
         }, NotFoundError | CompactionConflictError, never>;
         wait: () => Effect.Effect<void, NotFoundError, never>;
         resume: () => Effect.Effect<void, NotFoundError | import("./runner/index.js").RunError, never>;
         interrupt: (options?: {
-            readonly continue?: boolean;
+            readonly resume?: boolean;
         } | undefined) => Effect.Effect<boolean, never, never>;
         cancelInbox: (inboxID: string & import("effect/Brand").Brand<"Session.Message.ID">) => Effect.Effect<void, NotFoundError | InboxConflictError, never>;
         steerInbox: (inboxID: string & import("effect/Brand").Brand<"Session.Message.ID">) => Effect.Effect<void, NotFoundError | InboxConflictError, never>;

package/dist/types/session.d.ts

@@ -113,7 +113,7 @@ type CompactInput = Parameters<Session.Handle["compact"]>[0] & {
 };
 type ForkInput = {
     sessionID: SessionSchema.ID;
-    boundary: SessionSchema.ForkRequestBoundary;
+    before?: SessionMessage.ID;
 };
 export { AttachmentError, BusyError, CompactionConflictError, InboxConflictError, MessageDecodeError, MessageNotFoundError, NotFoundError, PromptConflictError, SkillNotFoundError, SyntheticConflictError, };
 type InboxItemRef = {
@@ -218,7 +218,7 @@ export interface Interface {
     readonly background: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>;
     readonly resume: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError | SessionRunner.RunError>;
     readonly interrupt: (sessionID: SessionSchema.ID, options?: {
-        readonly continue?: boolean;
+        readonly resume?: boolean;
     }) => Effect.Effect<boolean>;
     readonly synthetic: (input: Parameters<Session.Handle["synthetic"]>[0] & {
         sessionID: SessionSchema.ID;

package/dist/types/skill.d.ts

@@ -20,9 +20,8 @@ export declare const EmbeddedSource: import("effect/Schema").Struct<{
         readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Skill.ID">;
         readonly name: import("effect/Schema").brand<import("effect/Schema").String, "Skill.Name">;
         readonly description: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
-        readonly slash: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
         readonly autoinvoke: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
-        readonly location: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly path: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
         readonly content: import("effect/Schema").String;
     }>>;
 }>;
@@ -39,9 +38,8 @@ export declare const Source: import("effect/Schema").Union<readonly [import("eff
         readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Skill.ID">;
         readonly name: import("effect/Schema").brand<import("effect/Schema").String, "Skill.Name">;
         readonly description: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
-        readonly slash: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
         readonly autoinvoke: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
-        readonly location: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+        readonly path: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
         readonly content: import("effect/Schema").String;
     }>>;
 }>]> & {
@@ -53,9 +51,8 @@ export declare const Info: import("effect/Schema").Struct<{
     readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Skill.ID">;
     readonly name: import("effect/Schema").brand<import("effect/Schema").String, "Skill.Name">;
     readonly description: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").String>>, import("effect/Schema").optionalKey<import("effect/Schema").String>, never, never>;
-    readonly slash: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
     readonly autoinvoke: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Boolean>>, import("effect/Schema").optionalKey<import("effect/Schema").Boolean>, never, never>;
-    readonly location: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+    readonly path: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
     readonly content: import("effect/Schema").String;
 }>;
 export type Info = Skill.Info;

package/dist/types/state.d.ts

@@ -69,5 +69,9 @@ export interface Interface<State, Editor> extends Transformable<Editor> {
      * value and never touches earlier ones, so callers may retain what they read.
      */
     readonly get: () => State;
+    /** Marks a changed read-time dependency without scheduling another notification. */
+    readonly invalidate: () => void;
+    /** Changes synchronously, including batched edits and grouped-registration removal. */
+    readonly revision: () => number;
 }
 export declare function create<State, Editor>(options: Options<State, Editor>): Interface<State, Editor>;

package/dist/types/tool/plugin/opencode.d.ts

@@ -15,6 +15,13 @@ export declare const MoveInput: Schema.Struct<{
     }>;
     readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
 }>;
+export declare const ModelsInput: Schema.Struct<{
+    readonly query: Schema.optionalKey<Schema.String>;
+    readonly provider: Schema.optionalKey<Schema.String>;
+    readonly all: Schema.optionalKey<Schema.Boolean>;
+    readonly limit: Schema.optionalKey<Schema.Int>;
+    readonly offset: Schema.optionalKey<Schema.Int>;
+}>;
 export declare const Plugin: {
     id: string;
     effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope>;

package/dist/types/tool/plugin/subagent.d.ts

@@ -4,6 +4,7 @@ import { Effect, Schema } from "effect";
 import { Agent } from "../../agent.js";
 import { Config } from "../../config.js";
 import { Job } from "../../job.js";
+import { Model } from "../../model.js";
 import { Permission } from "../../permission.js";
 import { Session } from "../../session.js";
 export declare const name = "subagent";
@@ -11,6 +12,7 @@ export declare const Input: Schema.Struct<{
     readonly agent: Schema.String;
     readonly description: Schema.String;
     readonly prompt: Schema.String;
+    readonly model: Schema.optionalKey<Schema.String>;
     readonly sessionID: Schema.optionalKey<Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -28,5 +30,5 @@ export declare const Output: Schema.Struct<{
 export declare const description: string;
 export declare const Plugin: {
     id: string;
-    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Agent.Service | Config.Service | Permission.Service | Session.Service | Job.Service>;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Agent.Service | Model.Service | Config.Service | Permission.Service | Session.Service | Job.Service>;
 };

package/dist/types/util/git-executable.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveGitExecutable(platform: NodeJS.Platform, resolved: string | null): string;
+export declare const gitExecutable: string;

package/dist/types/v1/config/migrate.d.ts

@@ -84,8 +84,8 @@ export declare function migrate(info: typeof ConfigV1.Info.Type): {
     } | undefined;
     readonly mcp?: {
         readonly timeout?: {
-            readonly catalog?: number | undefined;
             readonly startup?: number | undefined;
+            readonly catalog?: number | undefined;
             readonly execution?: number | undefined;
         } | undefined;
         readonly servers?: {
@@ -94,10 +94,11 @@ export declare function migrate(info: typeof ConfigV1.Info.Type): {
                 readonly command: readonly string[];
                 readonly disabled?: boolean | undefined;
                 readonly timeout?: {
-                    readonly catalog?: number | undefined;
                     readonly startup?: number | undefined;
+                    readonly catalog?: number | undefined;
                     readonly execution?: number | undefined;
                 } | undefined;
+                readonly protocol?: "auto" | "legacy" | "2026-07-28" | undefined;
                 readonly cwd?: string | undefined;
                 readonly environment?: {
                     readonly [x: string]: string;
@@ -112,16 +113,18 @@ export declare function migrate(info: typeof ConfigV1.Info.Type): {
                     readonly client_secret?: string | undefined;
                     readonly callback_port?: number | undefined;
                     readonly redirect_uri?: string | undefined;
+                    readonly auth_server_metadata_url?: string | undefined;
                 } | undefined;
                 readonly disabled?: boolean | undefined;
                 readonly headers?: {
                     readonly [x: string]: string;
                 } | undefined;
                 readonly timeout?: {
-                    readonly catalog?: number | undefined;
                     readonly startup?: number | undefined;
+                    readonly catalog?: number | undefined;
                     readonly execution?: number | undefined;
                 } | undefined;
+                readonly protocol?: "auto" | "legacy" | "2026-07-28" | undefined;
                 readonly codemode?: boolean | undefined;
             };
         } | undefined;
@@ -152,7 +155,7 @@ export declare function migrate(info: typeof ConfigV1.Info.Type): {
                 readonly mode: "provider";
                 readonly threshold?: number | undefined;
             } | undefined;
-            readonly websocket?: boolean | undefined;
+            readonly transport?: "http" | "websocket" | undefined;
             readonly package?: string | undefined;
             readonly models?: {
                 readonly [x: string]: {
@@ -173,7 +176,7 @@ export declare function migrate(info: typeof ConfigV1.Info.Type): {
                         readonly mode: "provider";
                         readonly threshold?: number | undefined;
                     } | undefined;
-                    readonly websocket?: boolean | undefined;
+                    readonly transport?: "http" | "websocket" | undefined;
                     readonly package?: string | undefined;
                     readonly family?: string | undefined;
                     readonly compatibility?: {
@@ -182,6 +185,7 @@ export declare function migrate(info: typeof ConfigV1.Info.Type): {
                         readonly maxTokensField?: "max_completion_tokens" | "max_tokens" | undefined;
                         readonly requireFinishReason?: boolean | undefined;
                         readonly requireAssistantAfterTool?: boolean | undefined;
+                        readonly supportsPromptCacheKey?: boolean | undefined;
                     } | undefined;
                     readonly variants?: readonly {
                         readonly id: string;
@@ -224,10 +228,9 @@ export declare function migrate(info: typeof ConfigV1.Info.Type): {
                         readonly context?: number | undefined;
                     } | undefined;
                     readonly capabilities?: {
+                        readonly tools: boolean;
                         readonly input: readonly string[];
                         readonly output: readonly string[];
-                        readonly tools: boolean;
-                        readonly responsesWebsockets?: boolean | undefined;
                     } | undefined;
                     readonly modelID?: string | undefined;
                 };

package/dist/types/variant.d.ts

@@ -0,0 +1,14 @@
+export * as Variant from "./variant.js";
+import { Model } from "./model.js";
+export type Support = {
+    readonly type: "effort";
+    readonly values?: readonly string[];
+} | {
+    readonly type: "toggle";
+} | {
+    readonly type: "budget_tokens";
+    readonly min?: number;
+    readonly max?: number;
+};
+type Variants = Model.Info["variants"];
+export declare function resolve(model: Model.Info, supports?: readonly Support[]): Variants;

package/dist/types/worktree/git.d.ts

@@ -1,5 +1,6 @@
 export * as WorktreeGit from "./git.js";
 import { Effect } from "effect";
+import { Worktree } from "@opencode/schema/worktree";
 import { FSUtil } from "@opencode/util/fs-util";
 import { Git } from "../git.js";
 import { DirectoryUnavailableError } from "./directory.js";
@@ -16,8 +17,5 @@ export declare const make: Effect.Effect<{
         directory: import("@opencode/schema/schema").AbsolutePath;
         force: boolean;
     }) => Effect.Effect<undefined, Git.WorktreeError | DirectoryUnavailableError, never>;
-    list: (directory: string & import("effect/Brand").Brand<"AbsolutePath">) => Effect.Effect<{
-        readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
-        readonly type: "root" | "worktree";
-    }[], Git.WorktreeError | DirectoryUnavailableError, never>;
+    list: (directory: string & import("effect/Brand").Brand<"AbsolutePath">) => Effect.Effect<Worktree.ListEntry[], Git.WorktreeError | DirectoryUnavailableError, never>;
 }, never, FSUtil.Service | Git.Service>;

package/dist/types/worktree/strategies.d.ts

@@ -0,0 +1,36 @@
+export * as WorktreeStrategies from "./strategies.js";
+import { Context, Effect } from "effect";
+import { Worktree } from "@opencode/schema/worktree";
+import { AbsolutePath } from "../schema.js";
+import { State } from "../state.js";
+export interface Strategy {
+    readonly id: Worktree.StrategyID;
+    readonly create: (input: {
+        sourceDirectory: AbsolutePath;
+        directory: AbsolutePath;
+        branch?: string;
+    }) => Effect.Effect<Worktree.Info, unknown>;
+    readonly remove: (input: {
+        directory: AbsolutePath;
+        force: boolean;
+    }) => Effect.Effect<void, unknown>;
+    readonly list: (directory: AbsolutePath) => Effect.Effect<readonly Worktree.ListEntry[], unknown>;
+}
+export interface Editor {
+    readonly add: (strategy: Strategy) => void;
+    readonly configure: (settings: {
+        readonly directory: AbsolutePath;
+    }) => void;
+}
+export interface Interface extends State.Transformable<Editor> {
+    readonly directory: AbsolutePath;
+    readonly get: () => {
+        readonly directory: AbsolutePath;
+        readonly strategies: ReadonlyMap<Worktree.StrategyID, Strategy>;
+        readonly selected: Worktree.StrategyID;
+    };
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/WorktreeStrategies", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

package/dist/types/worktree.d.ts

@@ -1,17 +1,22 @@
 export * as Worktree from "./worktree.js";
 import { Context, Effect, Schema } from "effect";
-import { AbsolutePath } from "./schema.js";
 import { Git } from "./git.js";
+import { Node } from "@opencode/util/effect/app-node";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+import { Project } from "./project.js";
 import { Worktree } from "@opencode/schema/worktree";
 import { DirectoryUnavailableError } from "./worktree/directory.js";
 import { AppProcess } from "@opencode/util/process";
-import { State } from "./state.js";
+import { WorktreeStrategies } from "./worktree/strategies.js";
+export type { Strategy, Editor } from "./worktree/strategies.js";
 export { DirectoryUnavailableError } from "./worktree/directory.js";
 export { OperationError } from "@opencode/schema/worktree";
 export declare const StrategyID: Schema.brand<Schema.Trim, "Worktree.StrategyID">;
 export type StrategyID = typeof StrategyID.Type;
 export declare const CreateInput: 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>;
+    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>;
@@ -19,15 +24,13 @@ export declare const CreateInput: Schema.Struct<{
 }>;
 export type CreateInput = typeof CreateInput.Type;
 export declare const RemoveInput: 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;
 }>;
 export type RemoveInput = typeof RemoveInput.Type;
-export declare const RefreshResult: Schema.Struct<{
-    readonly updated: Schema.$Array<Schema.brand<Schema.String, "AbsolutePath">>;
-    readonly removed: Schema.$Array<Schema.brand<Schema.String, "AbsolutePath">>;
-}>;
-export type RefreshResult = typeof RefreshResult.Type;
 export declare const Info: Schema.Struct<{
     readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
 }>;
@@ -65,25 +68,7 @@ declare const StrategyUnavailableError_base: Schema.Class<StrategyUnavailableErr
 }>, import("effect/Cause").YieldableError>;
 export declare class StrategyUnavailableError extends StrategyUnavailableError_base {
 }
-declare const UnsupportedLocationError_base: Schema.Class<UnsupportedLocationError, Schema.TaggedStruct<"Worktree.UnsupportedLocationError", {
-    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
-}>, import("effect/Cause").YieldableError>;
-export declare class UnsupportedLocationError extends UnsupportedLocationError_base {
-}
-export type Error = SourceDirectoryNotFoundError | DestinationExistsError | DirectoryUnavailableError | InvalidDirectoryError | StrategyUnavailableError | UnsupportedLocationError | Worktree.OperationError | AppProcess.AppProcessError | Git.WorktreeError;
-export interface Strategy {
-    readonly id: StrategyID;
-    readonly create: (input: {
-        sourceDirectory: AbsolutePath;
-        directory: AbsolutePath;
-        branch?: string;
-    }) => Effect.Effect<Info, unknown>;
-    readonly remove: (input: {
-        directory: AbsolutePath;
-        force: boolean;
-    }) => Effect.Effect<void, unknown>;
-    readonly list: (directory: AbsolutePath) => Effect.Effect<readonly ListEntry[], unknown>;
-}
+export type Error = Project.NotFoundError | SourceDirectoryNotFoundError | DestinationExistsError | DirectoryUnavailableError | InvalidDirectoryError | StrategyUnavailableError | Worktree.OperationError | AppProcess.AppProcessError | Git.WorktreeError;
 export declare const Event: {
     Updated: Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -301,19 +286,17 @@ export declare const Event: {
         }>;
     }];
 };
-export interface Editor {
-    readonly add: (strategy: Strategy) => void;
-    readonly configure: (settings: {
-        readonly directory: AbsolutePath;
-    }) => void;
-}
-export interface Interface extends State.Transformable<Editor> {
-    readonly list: () => Effect.Effect<List, Error>;
-    readonly create: (input?: CreateInput) => Effect.Effect<Info, Error>;
-    readonly remove: (input: RemoveInput) => Effect.Effect<void, Error>;
-    readonly refresh: () => Effect.Effect<RefreshResult, Error>;
+export interface Interface {
+    readonly list: (input: {
+        projectID: Project.ID;
+    }) => Effect.Effect<List, Project.NotFoundError>;
+    readonly create: (input: CreateInput, current?: WorktreeStrategies.Interface) => Effect.Effect<Info, Error>;
+    readonly remove: (input: RemoveInput, current?: WorktreeStrategies.Interface) => Effect.Effect<void, Error>;
+    readonly refresh: (input: {
+        projectID: Project.ID;
+    }, current?: WorktreeStrategies.Interface) => Effect.Effect<void, Error>;
 }
-declare const Service_base: Context.ServiceClass<Service, "@opencode/v2/Worktree", Interface>;
+declare const Service_base: Context.ServiceClass<Service, "@opencode/Worktree", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;
+export declare const node: LayerNode.Provider<Service, never, typeof Node.tags.values.global>;

package/dist/util/error-summary.js

@@ -1,7 +1,7 @@
 import {
   from2,
   exports_error_summary
-} from "../chunks/mime-0q0f95c6.js";
+} from "../chunks/instruction-discovery-0q0f95c6.js";
 export {
   exports_error_summary as ErrorSummary,
   from2 as from

package/dist/util/error.js

@@ -1,6 +1,6 @@
 import {
   NamedError2
-} from "../chunks/mime-2axfhc9x.js";
+} from "../chunks/instruction-discovery-2axfhc9x.js";
 export {
   NamedError2 as NamedError
 };

package/dist/util/git-executable.js

@@ -0,0 +1,9 @@
+import {
+  resolveGitExecutable2,
+  gitExecutable2
+} from "../chunks/instruction-discovery-ef5x83kb.js";
+import"../chunks/instruction-discovery-qaymkmh1.js";
+export {
+  gitExecutable2 as gitExecutable,
+  resolveGitExecutable2 as resolveGitExecutable
+};

package/dist/util/iife.js

@@ -1,6 +1,6 @@
 import {
   iife2
-} from "../chunks/mime-1kg9ymc8.js";
+} from "../chunks/instruction-discovery-1kg9ymc8.js";
 export {
   iife2 as iife
 };

package/dist/util/lazy.js

@@ -1,6 +1,6 @@
 import {
   lazy2
-} from "../chunks/mime-88xbtdfr.js";
+} from "../chunks/instruction-discovery-88xbtdfr.js";
 export {
   lazy2 as lazy
 };

package/dist/util/slug.js

@@ -1,6 +1,6 @@
 import {
   Slug2
-} from "../chunks/mime-gebd4c9n.js";
+} from "../chunks/instruction-discovery-gebd4c9n.js";
 export {
   Slug2 as Slug
 };

package/dist/util/token.js

@@ -1,7 +1,7 @@
 import {
   estimate2,
   exports_token
-} from "../chunks/mime-h6vf3j39.js";
+} from "../chunks/instruction-discovery-h6vf3j39.js";
 export {
   exports_token as Token,
   estimate2 as estimate

package/dist/util/which.js

@@ -1,6 +1,6 @@
 import {
   which2
-} from "../chunks/mime-qaymkmh1.js";
+} from "../chunks/instruction-discovery-qaymkmh1.js";
 export {
   which2 as which
 };

package/dist/util/wildcard.js

@@ -1,7 +1,7 @@
 import {
   match2,
   exports_wildcard
-} from "../chunks/mime-y1fvbwt7.js";
+} from "../chunks/instruction-discovery-y1fvbwt7.js";
 export {
   exports_wildcard as Wildcard,
   match2 as match

package/dist/v1/config/agent.js

@@ -1,10 +1,10 @@
 import {
-  Info20,
-  exports_agent4
-} from "../../chunks/mime-qs001aqx.js";
-import"../../chunks/mime-xdk9p2qn.js";
-import"../../chunks/mime-922hggd3.js";
+  Info10,
+  exports_agent3
+} from "../../chunks/instruction-discovery-y7x142mt.js";
+import"../../chunks/instruction-discovery-a8bn8zg0.js";
+import"../../chunks/instruction-discovery-922hggd3.js";
 export {
-  exports_agent4 as ConfigAgentV1,
-  Info20 as Info
+  exports_agent3 as ConfigAgentV1,
+  Info10 as Info
 };

package/dist/v1/config/attachment.js

@@ -1,11 +1,11 @@
 import {
   Image2,
-  Info14,
+  Info6,
   exports_attachment
-} from "../../chunks/mime-c78bbtc9.js";
-import"../../chunks/mime-922hggd3.js";
+} from "../../chunks/instruction-discovery-78v47nsk.js";
+import"../../chunks/instruction-discovery-922hggd3.js";
 export {
   exports_attachment as ConfigAttachmentV1,
   Image2 as Image,
-  Info14 as Info
+  Info6 as Info
 };

package/dist/v1/config/command.js

@@ -1,8 +1,8 @@
 import {
-  Info13,
-  exports_command5
-} from "../../chunks/mime-6hh8tjw2.js";
+  Info8,
+  exports_command4
+} from "../../chunks/instruction-discovery-qm0v3jhh.js";
 export {
-  exports_command5 as ConfigCommandV1,
-  Info13 as Info
+  exports_command4 as ConfigCommandV1,
+  Info8 as Info
 };