@opencode/core 2.0.32 → 2.1.0

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

@@ -5,7 +5,7 @@ import type { Session } from "../session.js";
 import type { SessionMessage } from "./message.js";
 export declare const NO_TEXT = "Subagent completed without a text response.";
 export declare function text(message: SessionMessage.Info | undefined): string;
-export declare const deliver: (sessions: Pick<Session.Interface, "synthetic">, jobs: Pick<Job.Interface, "completeBackground">, input: Pick<Job.Info, "status" | "output" | "error" | "notificationID"> & {
+export declare const deliver: (sessions: Pick<Session.Interface, "synthetic">, jobs: Pick<Job.Interface, "completeBackground">, input: Pick<Job.Info, "error" | "notificationID" | "output" | "status"> & {
     recovery: Extract<Job.Recovery, {
         kind: "subagent";
     }>;

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

@@ -13,5 +13,5 @@ declare const Service_base: Context.ServiceClass<Service, "@opencode/SessionTitl
 export declare class Service extends Service_base {
 }
 export declare const isUntitled: (session: SessionSchema.Info) => boolean;
-export declare const layer: Layer.Layer<Service, never, Database.Service | Bus.Service | import("@opencode/ai").LLMClientService | SessionStore.Service | SessionContext.Service>;
+export declare const layer: Layer.Layer<Service, never, import("@opencode/ai").LLMClientService | Database.Service | Bus.Service | SessionStore.Service | SessionContext.Service>;
 export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;

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

@@ -187,9 +187,18 @@ export declare const Data: Schema.Struct<{
         }>>, never, never>;
     }>;
     readonly messages: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        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">;
+        };
+        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly time: Schema.Struct<{
+            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        }>;
         readonly type: Schema.tag<"agent-switched">;
         readonly agent: Schema.brand<Schema.String, "Agent.ID">;
         readonly previous: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Agent.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Agent.ID">>, never, never>;
+    }>, Schema.Struct<{
         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">;
@@ -198,7 +207,6 @@ export declare const Data: Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
-    }>, Schema.Struct<{
         readonly type: Schema.tag<"model-switched">;
         readonly model: Schema.Struct<{
             readonly id: Schema.brand<Schema.String, "Model.ID">;
@@ -268,6 +276,7 @@ export declare const Data: Schema.Struct<{
                 readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
             };
         }>, never, never>;
+    }>, Schema.Struct<{
         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">;
@@ -276,7 +285,6 @@ export declare const Data: Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
-    }>, Schema.Struct<{
         readonly type: Schema.tag<"location-switched">;
         readonly location: Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -329,6 +337,7 @@ export declare const Data: Schema.Struct<{
             }>, never, never>;
             readonly subpath: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "RelativePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "RelativePath">>, never, never>;
         }>>, never, never>;
+    }>, Schema.Struct<{
         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">;
@@ -337,7 +346,6 @@ export declare const Data: Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
-    }>, Schema.Struct<{
         readonly text: Schema.String;
         readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
             readonly data: Schema.String;
@@ -362,13 +370,13 @@ export declare const Data: Schema.Struct<{
         }> & {
             create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                 readonly data: string;
+                readonly mime: string;
                 readonly source: {
                     readonly type: "inline";
                 } | {
                     readonly type: "uri";
                     readonly uri: string;
                 };
-                readonly mime: string;
                 readonly name?: string | undefined;
                 readonly description?: string | undefined;
                 readonly mention?: {
@@ -400,13 +408,13 @@ export declare const Data: Schema.Struct<{
         }> & {
             create: (input: import("@opencode/schema/prompt").FileAttachment) => {
                 readonly data: string;
+                readonly mime: string;
                 readonly source: {
                     readonly type: "inline";
                 } | {
                     readonly type: "uri";
                     readonly uri: string;
                 };
-                readonly mime: string;
                 readonly name?: string | undefined;
                 readonly description?: string | undefined;
                 readonly mention?: {
@@ -467,6 +475,7 @@ export declare const Data: Schema.Struct<{
             }>>, never, never>;
         }>>>, never, never>;
         readonly type: Schema.tag<"user">;
+    }>, Schema.Struct<{
         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">;
@@ -475,10 +484,10 @@ export declare const Data: Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
-    }>, Schema.Struct<{
         readonly text: Schema.String;
         readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly type: Schema.tag<"synthetic">;
+    }>, Schema.Struct<{
         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">;
@@ -487,10 +496,10 @@ export declare const Data: Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
-    }>, Schema.Struct<{
         readonly type: Schema.tag<"system">;
         readonly text: Schema.String;
         readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>, Schema.Struct<{
         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">;
@@ -499,20 +508,16 @@ export declare const Data: Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
-    }>, Schema.Struct<{
         readonly type: Schema.tag<"skill">;
         readonly skill: Schema.brand<Schema.String, "Skill.ID">;
         readonly name: Schema.brand<Schema.String, "Skill.Name">;
         readonly text: Schema.String;
+    }>, Schema.Struct<{
         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">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-        readonly time: Schema.Struct<{
-            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-        }>;
-    }>, Schema.Struct<{
         readonly type: Schema.tag<"shell">;
         readonly shellID: Schema.brand<Schema.String, "Shell.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Shell.ID">;
@@ -536,12 +541,12 @@ export declare const Data: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
             readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
         }>;
+    }>, Schema.Struct<{
         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">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-    }>, Schema.Struct<{
         readonly type: Schema.tag<"assistant">;
         readonly agent: Schema.brand<Schema.String, "Agent.ID">;
         readonly model: Schema.Struct<{
@@ -570,11 +575,11 @@ export declare const Data: Schema.Struct<{
         readonly content: Schema.$Array<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
             readonly type: Schema.tag<"text">;
             readonly text: Schema.String;
-            readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+            readonly native: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         }>, Schema.Struct<{
             readonly type: Schema.tag<"reasoning">;
             readonly text: Schema.String;
-            readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+            readonly native: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
             readonly time: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
                 readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
                 readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
@@ -587,8 +592,7 @@ export declare const Data: Schema.Struct<{
             readonly id: Schema.String;
             readonly name: Schema.String;
             readonly executed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
-            readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-            readonly providerResultState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+            readonly native: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
             readonly state: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
                 readonly status: Schema.tag<"streaming">;
                 readonly input: Schema.String;
@@ -658,7 +662,7 @@ export declare const Data: Schema.Struct<{
         }>>, never, never>;
         readonly finish: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>>>, Schema.optionalKey<Schema.Literals<readonly ["stop", "length", "tool-calls", "content-filter", "error", "unknown"]>>, never, never>;
         readonly rawFinish: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly native: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
             zero: number & import("effect/Brand").Brand<"Money.USD">;
         }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
@@ -732,16 +736,20 @@ export declare const Data: Schema.Struct<{
             readonly streamed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
             readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
         }>;
+    }>, Schema.Union<readonly [Schema.Struct<{
         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">;
         };
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-    }>, Schema.Union<readonly [Schema.Struct<{
+        readonly time: Schema.Struct<{
+            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        }>;
+        readonly type: Schema.tag<"compaction">;
         readonly status: Schema.tag<"running">;
         readonly reason: Schema.Literals<readonly ["auto", "manual"]>;
         readonly summary: Schema.String;
-        readonly recent: Schema.String;
+    }>, Schema.Struct<{
         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">;
@@ -751,7 +759,6 @@ export declare const Data: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
         readonly type: Schema.tag<"compaction">;
-    }>, Schema.Struct<{
         readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
             zero: number & import("effect/Brand").Brand<"Money.USD">;
         }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
@@ -821,56 +828,9 @@ export declare const Data: Schema.Struct<{
                 readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
             };
         }>, never, never>;
-        readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+        readonly native: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
         readonly summary: Schema.String;
-        readonly recent: Schema.String;
-        readonly providerContext: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-            readonly version: Schema.Literal<1>;
-            readonly provenance: Schema.Struct<{
-                readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
-                    opencode: string & import("effect/Brand").Brand<"Provider.ID">;
-                    anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
-                    openai: string & import("effect/Brand").Brand<"Provider.ID">;
-                    google: string & import("effect/Brand").Brand<"Provider.ID">;
-                    googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
-                    githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
-                    amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
-                    azure: string & import("effect/Brand").Brand<"Provider.ID">;
-                    openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
-                    mistral: string & import("effect/Brand").Brand<"Provider.ID">;
-                    gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
-                };
-                readonly provider: Schema.String;
-                readonly modelID: Schema.String;
-                readonly route: Schema.String;
-                readonly protocol: Schema.String;
-                readonly endpoint: Schema.String;
-            }>;
-            readonly messages: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-        }>>>, Schema.optionalKey<Schema.Struct<{
-            readonly version: Schema.Literal<1>;
-            readonly provenance: Schema.Struct<{
-                readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
-                    opencode: string & import("effect/Brand").Brand<"Provider.ID">;
-                    anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
-                    openai: string & import("effect/Brand").Brand<"Provider.ID">;
-                    google: string & import("effect/Brand").Brand<"Provider.ID">;
-                    googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
-                    githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
-                    amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
-                    azure: string & import("effect/Brand").Brand<"Provider.ID">;
-                    openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
-                    mistral: string & import("effect/Brand").Brand<"Provider.ID">;
-                    gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
-                };
-                readonly provider: Schema.String;
-                readonly modelID: Schema.String;
-                readonly route: Schema.String;
-                readonly protocol: Schema.String;
-                readonly endpoint: Schema.String;
-            }>;
-            readonly messages: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-        }>>, never, never>;
+    }>, Schema.Struct<{
         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">;
@@ -880,7 +840,6 @@ export declare const Data: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
         readonly type: Schema.tag<"compaction">;
-    }>, Schema.Struct<{
         readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
             zero: number & import("effect/Brand").Brand<"Money.USD">;
         }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
@@ -915,6 +874,7 @@ export declare const Data: Schema.Struct<{
                 readonly body: Schema.String;
             }>>, never, never>;
         }>;
+    }>]>, Schema.Struct<{
         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">;
@@ -923,8 +883,6 @@ export declare const Data: Schema.Struct<{
         readonly time: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         }>;
-        readonly type: Schema.tag<"compaction">;
-    }>]>, 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<{
@@ -946,14 +904,6 @@ export declare const Data: 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">;
-        };
-        readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
-        readonly time: Schema.Struct<{
-            readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
-        }>;
     }>]>>;
 }>;
 export type Data = SessionTransfer.Data;

package/dist/types/session.d.ts

@@ -1,7 +1,7 @@
 export * as Session from "./session.js";
 export * from "./session/schema.js";
 import { Effect, Schema, Context, Stream } from "effect";
-import { ListAnchor } from "@opencode/schema/session";
+import { ListAnchor, ListCursor, ListFilter } from "@opencode/schema/session";
 import { Model } from "@opencode/schema/model";
 import { Location } from "./location.js";
 import type { FileSystem } from "./filesystem.js";
@@ -12,7 +12,7 @@ import { Agent } from "@opencode/schema/agent";
 import type { Permission } from "@opencode/schema/permission";
 import { SessionRunner } from "./session/runner/index.js";
 import { SessionStore } from "./session/store.js";
-import { AttachmentError, BusyError, CompactionConflictError, ForkEmptyError, InboxConflictError, MessageDecodeError, MessageNotFoundError, NotFoundError, PromptConflictError, SkillNotFoundError, SyntheticConflictError } from "./session/error.js";
+import { AttachmentError, BusyError, CompactionConflictError, ForkEmptyError, InboxConflictError, InvalidListCursorError, MessageDecodeError, MessageNotFoundError, NotFoundError, PromptConflictError, SkillNotFoundError, SyntheticConflictError } from "./session/error.js";
 import { Node } from "@opencode/util/effect/app-node";
 import { LayerNode } from "@opencode/util/effect/layer-node";
 import { SessionEvent } from "./session/event.js";
@@ -26,9 +26,8 @@ import type { EventLog } from "@opencode/schema/event-log";
 import type { FileDiff } from "@opencode/schema/file-diff";
 import type { Command } from "./command.js";
 import { SessionEnvironment } from "./session/environment.js";
-export { ListAnchor };
+export { ListAnchor, ListCursor };
 export declare const ListInput: Schema.Union<readonly [Schema.Struct<{
-    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
     readonly workspaceID: 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">;
@@ -40,6 +39,7 @@ export declare const ListInput: Schema.Union<readonly [Schema.Struct<{
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     }>>;
+    readonly archived: Schema.optional<Schema.Boolean>;
     readonly anchor: Schema.optional<Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -48,11 +48,8 @@ export declare const ListInput: Schema.Union<readonly [Schema.Struct<{
         readonly time: Schema.Finite;
         readonly direction: Schema.Literals<readonly ["previous", "next"]>;
     }>>;
+    readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
 }>, Schema.Struct<{
-    readonly project: Schema.brand<Schema.String, "Project.ID"> & {
-        global: string & import("effect/Brand").Brand<"Project.ID">;
-    };
-    readonly subpath: Schema.optional<Schema.brand<Schema.String, "RelativePath">>;
     readonly workspaceID: 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">;
@@ -64,6 +61,7 @@ export declare const ListInput: Schema.Union<readonly [Schema.Struct<{
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     }>>;
+    readonly archived: Schema.optional<Schema.Boolean>;
     readonly anchor: Schema.optional<Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -72,6 +70,10 @@ export declare const ListInput: Schema.Union<readonly [Schema.Struct<{
         readonly time: Schema.Finite;
         readonly direction: Schema.Literals<readonly ["previous", "next"]>;
     }>>;
+    readonly project: Schema.brand<Schema.String, "Project.ID"> & {
+        global: string & import("effect/Brand").Brand<"Project.ID">;
+    };
+    readonly subpath: Schema.optional<Schema.brand<Schema.String, "RelativePath">>;
 }>, Schema.Struct<{
     workspaceID: Schema.optional<Schema.brand<Schema.String, "Workspace.ID"> & {
         ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
@@ -84,6 +86,7 @@ export declare const ListInput: Schema.Union<readonly [Schema.Struct<{
         create: () => string & import("effect/Brand").Brand<"SessionID">;
         descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
     }>>;
+    archived: Schema.optional<Schema.Boolean>;
     anchor: Schema.optional<Schema.Struct<{
         readonly id: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -116,7 +119,7 @@ type ForkInput = {
     sessionID: SessionSchema.ID;
     before?: SessionMessage.ID;
 };
-export { AttachmentError, BusyError, CompactionConflictError, InboxConflictError, MessageDecodeError, MessageNotFoundError, NotFoundError, PromptConflictError, SkillNotFoundError, SyntheticConflictError, };
+export { AttachmentError, BusyError, CompactionConflictError, InboxConflictError, InvalidListCursorError, MessageDecodeError, MessageNotFoundError, NotFoundError, PromptConflictError, SkillNotFoundError, SyntheticConflictError, };
 type InboxItemRef = {
     readonly sessionID: SessionSchema.ID;
     readonly inboxID: SessionMessage.ID;
@@ -124,9 +127,17 @@ type InboxItemRef = {
 export { DestinationNotFoundError, DestinationNotDirectoryError, DestinationUnavailableError };
 export { TurnRangeError };
 export interface Interface {
-    readonly list: (input?: ListInput) => Effect.Effect<{
+    /** A cursor carries the filters of the request that produced it, so filters passed with a cursor are ignored. */
+    readonly list: (input?: ListFilter & {
+        readonly limit?: number;
+        readonly cursor?: ListCursor;
+    }) => Effect.Effect<{
         readonly data: SessionSchema.Info[];
-    }>;
+        readonly cursor: {
+            readonly previous?: ListCursor;
+            readonly next?: ListCursor;
+        };
+    }, InvalidListCursorError>;
     readonly create: (input: CreateInput) => Effect.Effect<SessionSchema.Info, NotFoundError>;
     readonly fork: (input: ForkInput) => Effect.Effect<SessionSchema.Info, NotFoundError | MessageNotFoundError | ForkEmptyError>;
     readonly get: (sessionID: SessionSchema.ID) => Effect.Effect<SessionSchema.Info, NotFoundError>;
@@ -185,6 +196,8 @@ export interface Interface {
         sessionID: SessionSchema.ID;
         title: string;
     }) => Effect.Effect<void, NotFoundError>;
+    readonly archive: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>;
+    readonly unarchive: (sessionID: SessionSchema.ID) => Effect.Effect<void, NotFoundError>;
     readonly setMetadata: (input: {
         sessionID: SessionSchema.ID;
         metadata: SessionSchema.Metadata;

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

@@ -18,10 +18,10 @@ export declare const unavailable: Shell.Output;
 export declare function output(result: Result): Output;
 export declare function notice(output: Pick<Output, "exit" | "signal" | "timeout">): string | undefined;
 export declare function metadata(output: Output): {
-    timeout?: boolean | undefined;
-    signal?: string | undefined;
-    exit?: number | undefined;
     truncated: boolean;
+    exit?: number | undefined;
+    signal?: string | undefined;
+    timeout?: boolean | undefined;
 };
 export declare function notification(input: {
     shellID: string;
@@ -33,26 +33,26 @@ export declare function notification(input: {
 }): {
     text: string;
     metadata: {
-        timeout?: boolean | undefined;
-        signal?: string | undefined;
-        exit?: number | undefined;
         truncated?: boolean | undefined;
-        state: "cancelled" | "error" | "completed";
-        jobID?: string | undefined;
+        exit?: number | undefined;
+        signal?: string | undefined;
+        timeout?: boolean | undefined;
         source: string;
         shellID: string;
+        jobID?: string | undefined;
+        state: "cancelled" | "completed" | "error";
     };
 };
 export declare function userNotification(result: Result): {
-    text: string;
     metadata: {
-        timeout?: boolean | undefined;
-        signal?: string | undefined;
-        exit?: number | undefined;
         truncated?: boolean | undefined;
-        state: "cancelled" | "error" | "completed";
-        jobID?: string | undefined;
+        exit?: number | undefined;
+        signal?: string | undefined;
+        timeout?: boolean | undefined;
         source: string;
         shellID: string;
+        jobID?: string | undefined;
+        state: "cancelled" | "completed" | "error";
     };
+    text: string;
 };

package/dist/types/skill.d.ts

@@ -1,5 +1,5 @@
 export * as Skill from "./skill.js";
-import type { FSUtil } from "@opencode/util/fs-util";
+import { FSUtil } from "@opencode/util/fs-util";
 import { Context, Effect, Types } from "effect";
 import { Skill } from "@opencode/schema/skill";
 import { Permission } from "./permission.js";

package/dist/types/state.d.ts

@@ -49,7 +49,7 @@ export declare function shutdown<A, E, R>(effect: Effect.Effect<A, E, R>): Effec
  * queued behind the layer's locks is interrupted with the layer. That interruption is not a failure.
  */
 export declare function reconcile(root: Scope.Scope, fork: (effect: Effect.Effect<void>) => Fiber.Fiber<void>, work: () => Effect.Effect<void>): Effect.Effect<void>;
-export declare const inherit: () => Effect.Effect<(<A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, never>>), never, never>;
+export declare const inherit: () => Effect.Effect<<A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, never>>, never, never>;
 export interface Options<State, Editor> {
     readonly name?: string;
     /** Creates the empty base value for every rebuild. */

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

@@ -22,11 +22,11 @@ declare const Output: Schema.Union<readonly [Schema.Struct<{
 }>, typeof ReadToolFileSystem.TextPage, typeof ReadToolFileSystem.ListPage]>;
 export declare const Plugin: {
     id: string;
-    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | FSUtil.Service | Location.Service | FileAccess.Service | ReadToolFileSystem.Service | SessionInstructions.Service>;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | FSUtil.Service | Location.Service | FileAccess.Service | SessionInstructions.Service | ReadToolFileSystem.Service>;
 };
 export declare const toModelContent: (path: string, offset: number | undefined, output: typeof Output.Type) => string | readonly [{
     readonly type: "text";
-    readonly text: "PDF read successfully" | "Image read successfully";
+    readonly text: "Image read successfully" | "PDF read successfully";
 }, {
     readonly type: "file";
     readonly uri: `data:${string};base64,${string}`;

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

@@ -19,5 +19,5 @@ export declare const Input: Schema.Struct<{
 }>;
 export declare const Plugin: {
     id: string;
-    effect: (ctx: Context) => Effect.Effect<void, never, Scope.Scope | Config.Service | Permission.Service | Environment.Service | FileAccess.Service | ShellSelect.Service | Job.Service | Session.Service | Shell.Service>;
+    effect: (ctx: Context) => Effect.Effect<void, never, Scope.Scope | Config.Service | Permission.Service | Environment.Service | FileAccess.Service | ShellSelect.Service | Job.Service | Shell.Service | Session.Service>;
 };

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

@@ -14,7 +14,7 @@ export declare const Output: Schema.Struct<{
     readonly output: Schema.String;
 }>;
 export declare const description: string;
-export declare const toModelOutput: (skill: Skill.Info, files: ReadonlyArray<string>) => string;
+export declare const toModelOutput: typeof Skill.toModelOutput;
 export declare const Plugin: {
     id: string;
     effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | FSUtil.Service | Permission.Service | Skill.Service>;

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

@@ -0,0 +1,29 @@
+export * as TodoTool from "./todo.js";
+import type { Context } from "@opencode/plugin/effect/plugin";
+import { Effect, Schema } from "effect";
+import { Config } from "../../config.js";
+import { Permission } from "../../permission.js";
+export declare const name = "todowrite";
+export declare const Info: Schema.Struct<{
+    readonly content: Schema.String;
+    readonly status: Schema.Literals<readonly ["pending", "in_progress", "completed", "cancelled"]>;
+}>;
+export type Info = typeof Info.Type;
+export declare const Input: Schema.Struct<{
+    readonly todos: Schema.$Array<Schema.Struct<{
+        readonly content: Schema.String;
+        readonly status: Schema.Literals<readonly ["pending", "in_progress", "completed", "cancelled"]>;
+    }>>;
+}>;
+export declare const Output: Schema.Struct<{
+    readonly todos: Schema.$Array<Schema.Struct<{
+        readonly content: Schema.String;
+        readonly status: Schema.Literals<readonly ["pending", "in_progress", "completed", "cancelled"]>;
+    }>>;
+}>;
+export type Output = typeof Output.Type;
+export declare const summarize: (todos: ReadonlyArray<Info>) => string;
+export declare const Plugin: {
+    id: string;
+    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | Config.Service | Permission.Service>;
+};

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

@@ -16,7 +16,7 @@ export declare const Input: Schema.Struct<{
 }>;
 export declare const Plugin: {
     id: string;
-    effect: (ctx: Context) => Effect.Effect<void, never, import("effect/Scope").Scope | HttpClient.HttpClient | Permission.Service>;
+    effect: (ctx: Context) => Effect.Effect<void, never, HttpClient.HttpClient | import("effect/Scope").Scope | Permission.Service>;
 };
 export declare function extractTextFromHTML(html: string): string;
 export { convertHTMLToMarkdown };

package/dist/types/tool/read-filesystem.d.ts

@@ -83,10 +83,10 @@ export interface Interface {
 declare const Service_base: Context.ServiceClass<Service, "@opencode/ReadToolFileSystem", Interface>;
 export declare class Service extends Service_base {
 }
-export declare const read: (files: Environment.Files, input: string & import("effect/Brand").Brand<"AbsolutePath">, resource: string, page?: {
-    readonly limit?: number | undefined;
+export declare const read: (files: Files, input: string & import("effect/Brand").Brand<"AbsolutePath">, resource: string, page?: {
     readonly offset?: number | undefined;
-} | undefined) => Effect.Effect<TextPage | ListPage | {
+    readonly limit?: number | undefined;
+} | undefined) => Effect.Effect<ListPage | TextPage | {
     type: "file";
     uri: string;
     name: string;
@@ -100,5 +100,5 @@ export declare const read: (files: Environment.Files, input: string & import("ef
     content: string;
     encoding: "utf8";
     mime: string;
-}, Environment.NotFound | Environment.Failed | BinaryFileError | MediaIngestLimitError | OffsetOutOfRangeError | PathKindError, never>;
+}, BinaryFileError | Environment.Failed | MediaIngestLimitError | Environment.NotFound | OffsetOutOfRangeError | PathKindError, never>;
 export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"location">>;