@opencode/core 2.0.26 → 2.0.28

package/dist/types/plugin/websearch/tavily.d.ts

@@ -1,5 +1,5 @@
 export * as WebSearchTavily from "./tavily.js";
 import { Scope } from "effect";
-import { HttpClient } from "effect/unstable/http";
+import { HttpClient } from "effect/http";
 export declare const endpoint = "https://api.tavily.com/search";
 export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<Scope.Scope | HttpClient.HttpClient>;

package/dist/types/plugin/websearch/tinyfish.d.ts

@@ -1,5 +1,5 @@
 export * as WebSearchTinyFish from "./tinyfish.js";
 import { Scope } from "effect";
-import { HttpClient } from "effect/unstable/http";
+import { HttpClient } from "effect/http";
 export declare const endpoint = "https://agent.tinyfish.ai/mcp";
 export declare const Plugin: import("@opencode/plugin/effect/plugin").Plugin<Scope.Scope | HttpClient.HttpClient>;

package/dist/types/project/schema.d.ts

@@ -37,6 +37,7 @@ export declare const Info: Schema.Struct<{
         readonly created: Schema.Int;
         readonly updated: Schema.Int;
         readonly active: Schema.Int;
+        readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
     }>;
     readonly sandboxes: Schema.$Array<Schema.String>;
 }>;
@@ -116,6 +117,7 @@ export declare const Event: {
                 readonly created: Schema.Int;
                 readonly updated: Schema.Int;
                 readonly active: Schema.Int;
+                readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
             }>;
             readonly sandboxes: Schema.$Array<Schema.String>;
         }>;
@@ -148,6 +150,7 @@ export declare const Event: {
                 readonly created: Schema.Int;
                 readonly updated: Schema.Int;
                 readonly active: Schema.Int;
+                readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
             }>;
             readonly sandboxes: Schema.$Array<Schema.String>;
         }>;
@@ -203,6 +206,7 @@ export declare const Event: {
                 readonly created: Schema.Int;
                 readonly updated: Schema.Int;
                 readonly active: Schema.Int;
+                readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
             }>;
             readonly sandboxes: Schema.$Array<Schema.String>;
         }>;
@@ -235,6 +239,7 @@ export declare const Event: {
                 readonly created: Schema.Int;
                 readonly updated: Schema.Int;
                 readonly active: Schema.Int;
+                readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
             }>;
             readonly sandboxes: Schema.$Array<Schema.String>;
         }>;

package/dist/types/project/sql.d.ts

@@ -39,6 +39,22 @@ export declare const ProjectTable: import("drizzle-orm/sqlite-core").SQLiteTable
             identity: undefined;
             generated: undefined;
         }, {}>;
+        time_archived: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "project";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
         sandboxes: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: string;
             tableName: "project";

package/dist/types/project.d.ts

@@ -45,6 +45,7 @@ export declare const Info: Schema.Struct<{
         readonly created: Schema.Int;
         readonly updated: Schema.Int;
         readonly active: Schema.Int;
+        readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
     }>;
     readonly sandboxes: Schema.$Array<Schema.String>;
 }>;
@@ -87,15 +88,22 @@ export interface Resolved {
     readonly vcs?: Vcs;
 }
 export declare const root: (fs: FSUtil.Interface, input: string & import("effect/Brand").Brand<"AbsolutePath">, markers?: readonly string[] | undefined) => Effect.Effect<(string & import("effect/Brand").Brand<"AbsolutePath">) | undefined, never, never>;
+export interface ListInput {
+    /** Includes archived Projects when true. */
+    readonly archived?: boolean;
+}
 export interface Interface {
-    readonly list: () => Effect.Effect<ReadonlyArray<Info>>;
+    readonly list: (input?: ListInput) => Effect.Effect<ReadonlyArray<Info>>;
     readonly update: (input: UpdateInput) => Effect.Effect<Info, NotFoundError>;
     /** Records Project activity for recency ordering, at most once per minute per Project. */
     readonly activate: (projectID: ID) => Effect.Effect<void>;
     /** Resolves and persists the owning Project. */
     readonly resolve: (input: AbsolutePath) => Effect.Effect<Resolved>;
+    /** Archives Projects whose known directories are all gone; resolving a Project unarchives it. */
+    readonly sweep: () => Effect.Effect<void>;
 }
 declare const Service_base: Context.ServiceClass<Service, "@opencode/Project", 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<"global">>;
+export declare const sweepNode: import("@opencode/util/effect/layer-node").Provider<never, never, import("@opencode/util/effect/layer-node").Tag<"global">>;

package/dist/types/provider.d.ts

@@ -42,8 +42,14 @@ export declare function nativeSettings(settings: Settings): Settings;
 export declare function modelSettings(settings: Settings | undefined): {
     readonly [x: string]: any;
 } | undefined;
-/** Applied to `headerTimeout` and `chunkTimeout` when provider settings leave them unset or invalid. */
+/** Applied to `headerTimeout` when provider settings leave it unset or invalid. */
 export declare const DEFAULT_TIMEOUT_MS = 300000;
+/**
+ * Applied to `chunkTimeout` when provider settings leave it unset or invalid. Some providers, such as DeepSeek, have
+ * specifically asked clients to allow at least 15 minutes, because their models can stream nothing for minutes while
+ * they reason.
+ */
+export declare const DEFAULT_CHUNK_TIMEOUT_MS = 900000;
 /** One timeout setting without a default; invalid values are dropped. */
 export declare function timeout(value: unknown): number | false | undefined;
 /** Request timeouts from provider settings, resolved for every route. `timeout` has no default. */
@@ -52,6 +58,8 @@ export declare function timeouts(settings: Readonly<Record<string, unknown>>): {
     headerTimeout: number | false;
     chunkTimeout: number | false;
 };
+/** Request body encoding from provider or model settings; invalid values are dropped. */
+export declare function encoding(settings: Readonly<Record<string, unknown>>): "zstd" | "gzip" | "none" | undefined;
 export declare function mergeOverlay(base: Readonly<Record<string, unknown>> | undefined, overlay: Readonly<Record<string, unknown>> | undefined): Record<string, Json> | undefined;
 export declare function mergeHeaders(base: Readonly<Record<string, string>> | undefined, overlay: Readonly<Record<string, string>> | undefined): {
     [k: string]: string;
@@ -71,6 +79,7 @@ export declare const Request: Schema.Struct<{
             readonly type: Schema.Literal<"native">;
         }>]>>, never, never>;
         readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
     }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>;
     readonly headers: Schema.$Record<Schema.String, Schema.String>;
     readonly body: Schema.$Record<Schema.String, Schema.Any>;
@@ -98,6 +107,7 @@ export declare const Settings: Schema.StructWithRest<Schema.Struct<{
         readonly type: Schema.Literal<"native">;
     }>]>>, never, never>;
     readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
+    readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
 }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>;
 export type Settings = Provider.Settings;
 export declare const Info: Schema.Struct<{
@@ -115,6 +125,7 @@ export declare const Info: Schema.Struct<{
             readonly type: Schema.Literal<"native">;
         }>]>>, never, never>;
         readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
     }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>>, Schema.optionalKey<Schema.StructWithRest<Schema.Struct<{
         readonly timeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
         readonly headerTimeout: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.Literal<false>]>>, never, never>;
@@ -129,6 +140,7 @@ export declare const Info: Schema.Struct<{
             readonly type: Schema.Literal<"native">;
         }>]>>, never, never>;
         readonly transport: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["http", "websocket"]>>>, Schema.optionalKey<Schema.Literals<readonly ["http", "websocket"]>>, never, never>;
+        readonly encoding: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["zstd", "gzip", "none"]>>>, Schema.optionalKey<Schema.Literals<readonly ["zstd", "gzip", "none"]>>, never, never>;
     }>, readonly [Schema.$Record<Schema.String, Schema.Any>]>>, never, never>;
     readonly headers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
     readonly body: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Any>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Any>>, never, never>;
@@ -174,6 +186,23 @@ export declare const Info: Schema.Struct<{
     readonly name: Schema.String;
     readonly activation: Schema.Literals<readonly ["auto", "enabled", "disabled"]>;
     readonly package: Schema.String;
+    readonly compatibility: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<Model.ReasoningField, Model.ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<Model.ReasoningField, Model.ReasoningField, never, never>>, never, never>;
+        readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+        readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly reasoningField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Codec<Model.ReasoningField, Model.ReasoningField, never, never>>>, Schema.optionalKey<Schema.Codec<Model.ReasoningField, Model.ReasoningField, never, never>>, never, never>;
+        readonly requireReasoning: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly maxTokensField: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>>, Schema.optionalKey<Schema.Literals<readonly ["max_completion_tokens", "max_tokens"]>>, never, never>;
+        readonly requireFinishReason: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly requireAssistantAfterTool: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly supportsPromptCacheKey: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        readonly cacheFormat: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["anthropic", "alibaba"]>>>, Schema.optionalKey<Schema.Literals<readonly ["anthropic", "alibaba"]>>, never, never>;
+    }>>, never, never>;
 }> & {
     empty: (id: Provider.ID) => Provider.Info;
 };

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

@@ -31,7 +31,7 @@ export declare class TurnRangeError extends TurnRangeError_base {
  * range spanning a location switch is rejected rather than diffed wrongly.
  */
 export declare const turn: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, locations: import("effect/LayerMap").LayerMap<Location.Ref, import("../instance.js").Services, import("../filesystem.js").DirectoryNotFoundError>, input: {
     readonly session: SessionSchema.Info;
     /** The process is currently executing this Session. */

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

@@ -10,7 +10,7 @@ import { SessionMessageTable } from "./sql.js";
  */
 export type Boundary = "latest" | "local" | SessionProviderContext.Provenance;
 export declare const latestCompaction: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">, boundary: Boundary) => Effect.Effect<{
     seq: number;
 } | undefined, never, never>;
@@ -421,9 +421,17 @@ export declare const decodeMessageRow: (row: typeof SessionMessageTable.$inferSe
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
+    readonly error?: {
+        readonly type: string;
+        readonly message: string;
+        readonly status?: number | undefined;
+        readonly response?: {
+            readonly body: string;
+        } | undefined;
+    } | undefined;
 }, MessageDecodeError, never>;
 export declare const load: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">, boundary: Boundary) => Effect.Effect<({
     readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
     readonly type: "agent-switched";
@@ -831,9 +839,17 @@ export declare const load: (db: import("../database/drizzle.js").EffectSQLiteDat
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
+    readonly error?: {
+        readonly type: string;
+        readonly message: string;
+        readonly status?: number | undefined;
+        readonly response?: {
+            readonly body: string;
+        } | undefined;
+    } | undefined;
 })[], MessageDecodeError, never>;
 export declare const entriesForRunner: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">, instructions: Instructions.List, boundary: Boundary) => Effect.Effect<{
     initial: string;
     entries: {
@@ -1245,11 +1261,19 @@ export declare const entriesForRunner: (db: import("../database/drizzle.js").Eff
             readonly metadata?: {
                 readonly [x: string]: unknown;
             } | undefined;
+            readonly error?: {
+                readonly type: string;
+                readonly message: string;
+                readonly status?: number | undefined;
+                readonly response?: {
+                    readonly body: string;
+                } | undefined;
+            } | undefined;
         };
     }[];
 }, never, never>;
 export declare const preview: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">, instructions: Instructions.List, boundary: Boundary) => Effect.Effect<{
     initial: string;
     messages: ({
@@ -1659,12 +1683,20 @@ export declare const preview: (db: import("../database/drizzle.js").EffectSQLite
         readonly metadata?: {
             readonly [x: string]: unknown;
         } | undefined;
+        readonly error?: {
+            readonly type: string;
+            readonly message: string;
+            readonly status?: number | undefined;
+            readonly response?: {
+                readonly body: string;
+            } | undefined;
+        } | undefined;
     })[];
     instructionUpdate: string;
 }, Instructions.InitializationBlocked, never>;
 /** Returns the session's first user message. */
 export declare const firstUserMessage: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">) => Effect.Effect<{
     readonly id: string & import("effect/Brand").Brand<"Session.Message.ID">;
     readonly type: "user";

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

@@ -26,7 +26,7 @@ declare const LifecycleConflict_base: Schema.Class<LifecycleConflict, Schema.Tag
 export declare class LifecycleConflict extends LifecycleConflict_base {
 }
 export declare const find: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, id: string & import("effect/Brand").Brand<"Session.Message.ID">) => Effect.Effect<{
     readonly type: "user";
     readonly payload: {
@@ -733,7 +733,7 @@ export declare const make: () => Effect.Effect<{
 export declare const layer: Layer.Layer<Service, never, Database.Service | Bus.Service>;
 export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;
 export declare const projectAdmitted: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, request: {
     readonly enqueuedSeq: number;
     readonly id: SessionMessage.ID;
@@ -747,7 +747,7 @@ export declare const projectAdmitted: (db: import("../database/drizzle.js").Effe
  * makes the table pending-only.
  */
 export declare const projectDelivered: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, input: PendingRef) => Effect.Effect<{
     readonly type: "user";
     readonly payload: {
@@ -839,15 +839,15 @@ export declare const projectDelivered: (db: import("../database/drizzle.js").Eff
     };
 }, never, never>;
 export declare const projectCancelled: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, input: PendingRef) => Effect.Effect<undefined, never, never>;
 export declare const projectDeliveryChanged: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, input: PendingRef & {
     readonly delivery: Delivery;
 }) => Effect.Effect<undefined, never, never>;
 export declare const list: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">) => Effect.Effect<({
     readonly type: "user";
     readonly payload: {
@@ -939,12 +939,12 @@ export declare const list: (db: import("../database/drizzle.js").EffectSQLiteDat
     };
 })[], never, never>;
 export declare const moveIDs: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">) => Effect.Effect<{
     id: string & import("effect/Brand").Brand<"Session.Message.ID">;
 }[], never, never>;
 export declare const nextPromotable: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">, promotable: Promotable) => Effect.Effect<{
     readonly type: "user";
     readonly payload: {
@@ -1038,7 +1038,7 @@ export declare const nextPromotable: (db: import("../database/drizzle.js").Effec
 /** Which pending rows count: "input" means any item in either delivery mode. */
 export type Scope = "input" | Delivery;
 export declare const has: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">, scope: Scope) => Effect.Effect<boolean, never, never>;
 /**
  * Promotes pending input into visible messages and returns the promoted count,
@@ -1047,5 +1047,5 @@ export declare const has: (db: import("../database/drizzle.js").EffectSQLiteData
  * Only the "input" scope may fall through to one queued input.
  */
 export declare const promote: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, bus: Bus.Interface, sessionID: string & import("effect/Brand").Brand<"SessionID">, scope: Promotable) => Effect.Effect<number | undefined, never, never>;

package/dist/types/session/instruction-entry.d.ts

@@ -19,14 +19,14 @@ export type Snapshot = typeof Snapshot.Type;
 export declare const MaxValueBytes: number;
 export declare const ValueTooLargeError: typeof InstructionEntry.ValueTooLargeError;
 export declare const snapshot: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">) => Effect.Effect<{
     key: string;
     value: Schema.Json;
     removed: boolean;
 }[], never, never>;
 export declare const initialize: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">, entries: readonly {
     readonly removed: boolean;
     readonly key: string;

package/dist/types/session/instruction-state.d.ts

@@ -10,38 +10,38 @@ export interface Observation extends Instructions.Admission {
     readonly current: Instructions.Values;
 }
 export declare const observe: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, instructions: Instructions.List, sessionID: string & import("effect/Brand").Brand<"SessionID">) => Effect.Effect<Observation, Instructions.InitializationBlocked, never>;
 export declare const commit: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, bus: Bus.Interface, instructions: Instructions.List, observation: Observation) => Effect.Effect<void, never, never>;
 export declare const prepare: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, bus: Bus.Interface, instructions: Instructions.List, sessionID: string & import("effect/Brand").Brand<"SessionID">) => Effect.Effect<void, Instructions.InitializationBlocked, never>;
 export declare const apply: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">, seq: number, delta: {
     readonly [x: string]: (string & import("effect/Brand").Brand<"Instruction.Hash">) | "removed";
 }) => Effect.Effect<void, never, never>;
 export declare const initialize: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">, seq: number, values: Readonly<Record<string, string & import("effect/Brand").Brand<"Instruction.Hash">>>) => Effect.Effect<void, never, never>;
 export declare const advanceEpoch: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">, epochStart: number) => Effect.Effect<void, never, never>;
 export declare const reset: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">) => Effect.Effect<void, never, never>;
 /** Renders the epoch baseline shown at the start of every model request. */
 export declare const initial: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">, instructions: Instructions.List) => Effect.Effect<string, never, never>;
 /** The current instruction values, used to seed a fork's baseline. */
 export declare const current: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">) => Effect.Effect<Readonly<Record<string, string & import("effect/Brand").Brand<"Instruction.Hash">>> | undefined, never, never>;
 export declare const preview: (db: import("../database/drizzle.js").EffectSQLiteDatabase<import("drizzle-orm").EmptyRelations> & {
-    $client: import("effect/unstable/sql/SqlClient").SqlClient;
+    $client: import("effect/sql/SqlClient").SqlClient;
 }, sessionID: string & import("effect/Brand").Brand<"SessionID">, instructions: Instructions.List, observed: Instructions.ReadResult) => Effect.Effect<{
     initial: string;
     update: string;

package/dist/types/session/model-transport.d.ts

@@ -1,7 +1,7 @@
 export * as SessionModelTransport from "./model-transport.js";
 import { type WebSocketChannelExecutor, type WebSocketConnector } from "@opencode/ai/route";
 import { Context, Effect, Layer } from "effect";
-import { Socket } from "effect/unstable/socket";
+import { Socket } from "effect/socket";
 import { SessionSchema } from "./schema.js";
 /** Selects the connection for one exchange. Its output feeds the affinity key, so changed headers reopen the socket. */
 export interface Handshake {

package/dist/types/session/subagent-job.d.ts

@@ -1,13 +1,17 @@
 export * as SubagentJob from "./subagent-job.js";
-import { Effect, Scope } from "effect";
+import { Context, Effect } from "effect";
+import { Node } from "@opencode/util/effect/app-node";
+import type { LayerNode } from "@opencode/util/effect/layer-node";
 import { Job } from "../job.js";
-import { Session } from "../session.js";
 type Recovery = Extract<Job.Recovery, {
     kind: "subagent";
 }>;
-interface Runner {
+export interface Interface {
     start: (recovery: Recovery) => Effect.Effect<Job.Info>;
     background: (recovery: Recovery) => Effect.Effect<void>;
     notify: (recovery: Recovery, startedAt: number) => Effect.Effect<void>;
 }
-export declare const make: Effect.Effect<Runner, never, Session.Service | Job.Service | Scope.Scope>;
+declare const Service_base: Context.ServiceClass<Service, "@opencode/SubagentJob", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const node: LayerNode.Provider<Service, never, typeof Node.tags.values.global>;

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

@@ -927,6 +927,25 @@ export declare const Data: Schema.Struct<{
     }>]>, Schema.Struct<{
         readonly type: Schema.tag<"idle">;
         readonly outcome: Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>;
+        readonly error: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+            readonly type: Schema.String;
+            readonly message: Schema.String;
+            readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>, never, never>;
+        }>>>, Schema.optionalKey<Schema.Struct<{
+            readonly type: Schema.String;
+            readonly message: Schema.String;
+            readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+            readonly response: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>>, Schema.optionalKey<Schema.Struct<{
+                readonly body: Schema.String;
+            }>>, never, never>;
+        }>>, never, never>;
         readonly id: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
             fromEvent: (eventID: import("@opencode/schema/event").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;

package/dist/types/shell/parse.d.ts

@@ -1,5 +1,6 @@
 export * as ShellParse from "./parse.js";
 import { Effect } from "effect";
+import { shellParserWasm } from "#shell-parser-wasm";
 export type Result = {
     commands: Array<{
         resource: string;
@@ -9,5 +10,6 @@ export type Result = {
 };
 export declare const scan: (command: string, shell: string, cwd: string, options?: {
     portable?: boolean;
+    wasm?: typeof shellParserWasm;
 } | undefined) => Effect.Effect<Result, Error, never>;
 export declare const scanPortable: (command: string, shell: string, cwd: string) => Effect.Effect<Result, Error, never>;

package/dist/types/tool/http-body.d.ts

@@ -1,3 +1,3 @@
 import { Effect } from "effect";
-import { HttpClientResponse } from "effect/unstable/http";
-export declare const collectBoundedResponseBody: (response: HttpClientResponse.HttpClientResponse, maximumBytes: number, tooLarge: () => Error) => Effect.Effect<Buffer<ArrayBuffer>, Error | import("effect/unstable/http/HttpClientError").HttpClientError, never>;
+import { HttpClientResponse } from "effect/http";
+export declare const collectBoundedResponseBody: (response: HttpClientResponse.HttpClientResponse, maximumBytes: number, tooLarge: () => Error) => Effect.Effect<Buffer<ArrayBuffer>, Error | import("effect/http/HttpClientError").HttpClientError, never>;

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

@@ -1,6 +1,8 @@
 export * as OpenCodeTools from "./opencode.js";
 import type { Context } from "@opencode/plugin/effect/plugin";
 import { Effect, Schema } from "effect";
+import { FileAccess } from "../../file-access.js";
+import { Permission } from "../../permission.js";
 export declare const RenameInput: Schema.Struct<{
     readonly sessionID: Schema.optionalKey<Schema.brand<Schema.String, "SessionID"> & {
         create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -15,6 +17,13 @@ export declare const MoveInput: Schema.Struct<{
     }>;
     readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
 }>;
+export declare const WorktreeCreateInput: Schema.Struct<{
+    readonly name: Schema.Trim;
+}>;
+export declare const WorktreeRemoveInput: Schema.Struct<{
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+    readonly force: Schema.optionalKey<Schema.Boolean>;
+}>;
 export declare const ModelsInput: Schema.Struct<{
     readonly query: Schema.optionalKey<Schema.String>;
     readonly provider: Schema.optionalKey<Schema.String>;
@@ -24,5 +33,5 @@ export declare const ModelsInput: Schema.Struct<{
 }>;
 export declare const Plugin: {
     id: string;
-    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope>;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Permission.Service | FileAccess.Service>;
 };

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

@@ -7,6 +7,7 @@ import { Job } from "../../job.js";
 import { Model } from "../../model.js";
 import { Permission } from "../../permission.js";
 import { Session } from "../../session.js";
+import { SubagentJob } from "../../session/subagent-job.js";
 export declare const name = "subagent";
 export declare const Input: Schema.Struct<{
     readonly agent: Schema.String;
@@ -30,5 +31,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 | Model.Service | Config.Service | Permission.Service | Job.Service | Session.Service>;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Agent.Service | Model.Service | Config.Service | Permission.Service | Job.Service | Session.Service | SubagentJob.Service>;
 };

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

@@ -1,7 +1,7 @@
 export * as WebFetchTool from "./webfetch.js";
 import type { Context } from "@opencode/plugin/effect/plugin";
 import { Effect, Schema } from "effect";
-import { HttpClient } from "effect/unstable/http";
+import { HttpClient } from "effect/http";
 import { Permission } from "../../permission.js";
 import { convertHTMLToMarkdown } from "../html-markdown.js";
 export declare const name = "webfetch";