npm - @opencode-ai/protocol - Versions diffs - 0.0.0-next-14798 → 0.0.0-next-14801 - Mend

@opencode-ai/protocol 0.0.0-next-14798 → 0.0.0-next-14801

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/groups/event.d.ts +1091 -2982
package/dist/groups/event.js +0 -1
package/dist/groups/session.d.ts +535 -628
package/package.json +2 -2

package/dist/groups/session.d.ts CHANGED Viewed

@@ -1763,21 +1763,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
     after: Schema.optional<Schema.compose<Schema.brand<Schema.Int, "Event.Seq">, Schema.NumberFromString>>;
     follow: Schema.optional<Schema.decodeTo<Schema.Boolean, Schema.Literals<readonly ["true", "false"]>, never, never>>;
-}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiSchema.StreamSse<HttpApiSchema.SseEventFromData<Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+}>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiSchema.StreamSse<HttpApiSchema.SseEventFromData<Schema.Union<readonly [Schema.Union<readonly ((Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.agent.switched">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -1809,6 +1805,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.agent.switched";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -1820,26 +1822,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.agent.switched";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.model.switched">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -1887,6 +1880,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.model.switched";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -1914,26 +1913,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.model.switched";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.moved">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -1972,6 +1962,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.moved";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly location: Schema.Struct<{
             readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
@@ -1990,26 +1986,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.moved";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.renamed">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -2038,6 +2025,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.renamed";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly title: Schema.String;
         readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
@@ -2046,26 +2039,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.renamed";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.forked">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -2102,6 +2086,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.forked";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly parentID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -2118,26 +2108,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.forked";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.prompted">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -2293,6 +2274,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.prompted";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -2428,26 +2415,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.prompted";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.prompt.admitted">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -2603,6 +2581,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.prompt.admitted";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -2738,26 +2722,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.prompt.admitted";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.context.updated">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -2789,6 +2764,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.context.updated";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -2800,26 +2781,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.context.updated";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.synthetic">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -2853,6 +2825,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.synthetic";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -2866,26 +2844,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.synthetic";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.skill.activated">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -2918,6 +2887,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.skill.activated";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -2930,26 +2905,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.skill.activated";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.shell.started">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -2982,6 +2948,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.shell.started";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -2994,26 +2966,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.shell.started";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.shell.ended">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -3043,6 +3006,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.shell.ended";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly callID: Schema.String;
         readonly output: Schema.String;
@@ -3052,26 +3021,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.shell.ended";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.step.started">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -3121,6 +3081,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.step.started";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -3150,26 +3116,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.step.started";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.step.ended">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -3213,6 +3170,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.step.ended";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -3236,26 +3199,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.step.ended";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.step.failed">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -3290,6 +3244,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.step.failed";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -3304,26 +3264,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.step.failed";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.text.started">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -3355,6 +3306,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.text.started";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -3366,26 +3323,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.text.started";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.text.ended">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -3418,6 +3366,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.text.ended";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -3430,26 +3384,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.text.ended";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.tool.input.started">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly type: Schema.Literal<"session.next.reasoning.started">;
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -3470,11 +3415,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         }>, never, never>;
     }>>, never, never>;
     readonly data: Schema.Struct<{
-        readonly name: Schema.String;
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
-        readonly callID: Schema.String;
+        readonly reasoningID: Schema.String;
+        readonly providerMetadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
         readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -3482,38 +3427,35 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.reasoning.started";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
-        readonly name: Schema.String;
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
-        readonly callID: Schema.String;
+        readonly reasoningID: Schema.String;
+        readonly providerMetadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
         readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.tool.input.started";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.tool.input.ended">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly type: Schema.Literal<"session.next.reasoning.ended">;
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -3534,11 +3476,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         }>, never, never>;
     }>>, never, never>;
     readonly data: Schema.Struct<{
-        readonly text: Schema.String;
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
-        readonly callID: Schema.String;
+        readonly reasoningID: Schema.String;
+        readonly text: Schema.String;
+        readonly providerMetadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
         readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -3546,38 +3489,36 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.reasoning.ended";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
-        readonly text: Schema.String;
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
-        readonly callID: Schema.String;
+        readonly reasoningID: Schema.String;
+        readonly text: Schema.String;
+        readonly providerMetadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
         readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.tool.input.ended";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.tool.called">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly type: Schema.Literal<"session.next.tool.input.started">;
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -3598,12 +3539,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         }>, never, never>;
     }>>, never, never>;
     readonly data: Schema.Struct<{
-        readonly tool: Schema.String;
-        readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
-        readonly provider: Schema.Struct<{
-            readonly executed: Schema.Boolean;
-            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
-        }>;
+        readonly name: Schema.String;
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
@@ -3615,13 +3551,14 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.tool.input.started";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
-        readonly tool: Schema.String;
-        readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
-        readonly provider: Schema.Struct<{
-            readonly executed: Schema.Boolean;
-            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
-        }>;
+        readonly name: Schema.String;
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
@@ -3632,26 +3569,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.tool.called";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.tool.progress">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly type: Schema.Literal<"session.next.tool.input.ended">;
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -3672,16 +3600,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         }>, never, never>;
     }>>, never, never>;
     readonly data: Schema.Struct<{
-        readonly structured: Schema.$Record<Schema.String, Schema.Unknown>;
-        readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-            readonly type: Schema.Literal<"text">;
-            readonly text: Schema.String;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"file">;
-            readonly uri: Schema.String;
-            readonly mime: Schema.String;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        }>]>>;
+        readonly text: Schema.String;
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
@@ -3693,17 +3612,14 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.tool.input.ended";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
-        readonly structured: Schema.$Record<Schema.String, Schema.Unknown>;
-        readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-            readonly type: Schema.Literal<"text">;
-            readonly text: Schema.String;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"file">;
-            readonly uri: Schema.String;
-            readonly mime: Schema.String;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        }>]>>;
+        readonly text: Schema.String;
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
@@ -3714,26 +3630,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.tool.progress";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.tool.success">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly type: Schema.Literal<"session.next.tool.called">;
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -3754,18 +3661,8 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         }>, never, never>;
     }>>, never, never>;
     readonly data: Schema.Struct<{
-        readonly structured: Schema.$Record<Schema.String, Schema.Unknown>;
-        readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-            readonly type: Schema.Literal<"text">;
-            readonly text: Schema.String;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"file">;
-            readonly uri: Schema.String;
-            readonly mime: Schema.String;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        }>]>>;
-        readonly outputPaths: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
-        readonly result: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Unknown>>, Schema.optionalKey<Schema.Unknown>, never, never>;
+        readonly tool: Schema.String;
+        readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
         readonly provider: Schema.Struct<{
             readonly executed: Schema.Boolean;
             readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
@@ -3781,19 +3678,15 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.tool.called";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
-        readonly structured: Schema.$Record<Schema.String, Schema.Unknown>;
-        readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-            readonly type: Schema.Literal<"text">;
-            readonly text: Schema.String;
-        }>, Schema.Struct<{
-            readonly type: Schema.Literal<"file">;
-            readonly uri: Schema.String;
-            readonly mime: Schema.String;
-            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        }>]>>;
-        readonly outputPaths: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
-        readonly result: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Unknown>>, Schema.optionalKey<Schema.Unknown>, never, never>;
+        readonly tool: Schema.String;
+        readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
         readonly provider: Schema.Struct<{
             readonly executed: Schema.Boolean;
             readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
@@ -3808,26 +3701,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.tool.success";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.tool.failed">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly type: Schema.Literal<"session.next.tool.progress">;
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -3848,15 +3732,16 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         }>, never, never>;
     }>>, never, never>;
     readonly data: Schema.Struct<{
-        readonly error: Schema.Struct<{
-            readonly type: Schema.Literal<"unknown">;
-            readonly message: Schema.String;
-        }>;
-        readonly result: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Unknown>>, Schema.optionalKey<Schema.Unknown>, never, never>;
-        readonly provider: Schema.Struct<{
-            readonly executed: Schema.Boolean;
-            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
-        }>;
+        readonly structured: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"file">;
+            readonly uri: Schema.String;
+            readonly mime: Schema.String;
+            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>]>>;
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
@@ -3868,16 +3753,23 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.tool.progress";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
-        readonly error: Schema.Struct<{
-            readonly type: Schema.Literal<"unknown">;
-            readonly message: Schema.String;
-        }>;
-        readonly result: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Unknown>>, Schema.optionalKey<Schema.Unknown>, never, never>;
-        readonly provider: Schema.Struct<{
-            readonly executed: Schema.Boolean;
-            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
-        }>;
+        readonly structured: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"file">;
+            readonly uri: Schema.String;
+            readonly mime: Schema.String;
+            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>]>>;
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
@@ -3888,26 +3780,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.tool.failed";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.reasoning.started">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly type: Schema.Literal<"session.next.tool.success">;
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -3928,11 +3811,26 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         }>, never, never>;
     }>>, never, never>;
     readonly data: Schema.Struct<{
+        readonly structured: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"file">;
+            readonly uri: Schema.String;
+            readonly mime: Schema.String;
+            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>]>>;
+        readonly outputPaths: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+        readonly result: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Unknown>>, Schema.optionalKey<Schema.Unknown>, never, never>;
+        readonly provider: Schema.Struct<{
+            readonly executed: Schema.Boolean;
+            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
+        }>;
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
-        readonly reasoningID: Schema.String;
-        readonly providerMetadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
+        readonly callID: Schema.String;
         readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -3940,38 +3838,50 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.tool.success";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
+        readonly structured: Schema.$Record<Schema.String, Schema.Unknown>;
+        readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"text">;
+            readonly text: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"file">;
+            readonly uri: Schema.String;
+            readonly mime: Schema.String;
+            readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        }>]>>;
+        readonly outputPaths: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+        readonly result: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Unknown>>, Schema.optionalKey<Schema.Unknown>, never, never>;
+        readonly provider: Schema.Struct<{
+            readonly executed: Schema.Boolean;
+            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
+        }>;
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
-        readonly reasoningID: Schema.String;
-        readonly providerMetadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
+        readonly callID: Schema.String;
         readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.reasoning.started";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.reasoning.ended">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly type: Schema.Literal<"session.next.tool.failed">;
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -3992,12 +3902,19 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         }>, never, never>;
     }>>, never, never>;
     readonly data: Schema.Struct<{
+        readonly error: Schema.Struct<{
+            readonly type: Schema.Literal<"unknown">;
+            readonly message: Schema.String;
+        }>;
+        readonly result: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Unknown>>, Schema.optionalKey<Schema.Unknown>, never, never>;
+        readonly provider: Schema.Struct<{
+            readonly executed: Schema.Boolean;
+            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
+        }>;
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
-        readonly reasoningID: Schema.String;
-        readonly text: Schema.String;
-        readonly providerMetadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
+        readonly callID: Schema.String;
         readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -4005,39 +3922,43 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.tool.failed";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
+        readonly error: Schema.Struct<{
+            readonly type: Schema.Literal<"unknown">;
+            readonly message: Schema.String;
+        }>;
+        readonly result: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Unknown>>, Schema.optionalKey<Schema.Unknown>, never, never>;
+        readonly provider: Schema.Struct<{
+            readonly executed: Schema.Boolean;
+            readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
+        }>;
         readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
-        readonly reasoningID: Schema.String;
-        readonly text: Schema.String;
-        readonly providerMetadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.$Record<Schema.String, Schema.Unknown>>>, never, never>;
+        readonly callID: Schema.String;
         readonly timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.reasoning.ended";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.retried">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -4074,6 +3995,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.retried";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly attempt: Schema.Finite;
         readonly error: Schema.Struct<{
@@ -4090,26 +4017,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.retried";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.compaction.started">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -4141,6 +4059,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.compaction.started";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -4152,26 +4076,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.compaction.started";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.compaction.ended">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -4205,6 +4120,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.compaction.ended";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -4218,26 +4139,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.compaction.ended";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.revert.staged">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -4286,6 +4198,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.revert.staged";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly revert: Schema.Struct<{
             readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
@@ -4314,26 +4232,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.revert.staged";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.revert.cleared">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -4361,6 +4270,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.revert.cleared";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         timestamp: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         sessionID: Schema.brand<Schema.String, "SessionID"> & {
@@ -4368,26 +4283,17 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.revert.cleared";
-}, Schema.Struct<{
+}) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.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 type: Schema.Literal<"session.next.revert.committed">;
-    readonly durable: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+    readonly durable: Schema.Struct<{
         readonly aggregateID: Schema.String;
         readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
         readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly aggregateID: Schema.String;
-        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
-        readonly version: Schema.brand<Schema.Int, "Event.Version">;
-    }>>, never, never>;
+    }>;
     readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
         readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
@@ -4418,6 +4324,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
         };
     }>;
 }> & {
+    type: "session.next.revert.committed";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
     data: Schema.Struct<{
         readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -4428,18 +4340,18 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
-    durable?: {
-        readonly version: number;
-        readonly aggregate: string;
-    } | undefined;
-    type: "session.next.revert.committed";
-}]>, Schema.Struct<{
+}))[]>, Schema.Struct<{
     readonly type: Schema.Literal<"log.synced">;
     readonly aggregateID: Schema.String;
     readonly seq: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Int, "Event.Seq">>>, Schema.optionalKey<Schema.brand<Schema.Int, "Event.Seq">>, never, never>;
 }>]>>, Schema.Never, {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.agent.switched";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly agent: string;
@@ -4449,11 +4361,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4461,6 +4368,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.model.switched";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly model: {
@@ -4474,11 +4386,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4486,6 +4393,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.moved";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly location: {
             readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
@@ -4498,11 +4410,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4510,6 +4417,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.renamed";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly title: string;
         readonly timestamp: import("effect/DateTime").Utc;
@@ -4518,11 +4430,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4530,6 +4437,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.forked";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly parentID: string & import("effect/Brand").Brand<"SessionID">;
         readonly timestamp: import("effect/DateTime").Utc;
@@ -4539,11 +4451,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4551,6 +4458,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.prompted";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly prompt: {
@@ -4582,11 +4494,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4594,6 +4501,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.prompt.admitted";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly prompt: {
@@ -4625,11 +4537,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4637,6 +4544,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.context.updated";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly text: string;
@@ -4646,11 +4558,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4658,6 +4565,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.synthetic";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly text: string;
@@ -4671,11 +4583,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4683,6 +4590,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.skill.activated";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly name: string;
@@ -4693,11 +4605,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4705,6 +4612,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.shell.started";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly callID: string;
@@ -4715,11 +4627,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4727,6 +4634,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.shell.ended";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly callID: string;
         readonly output: string;
@@ -4736,11 +4648,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4748,6 +4655,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.step.started";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly agent: string;
@@ -4763,11 +4675,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4775,6 +4682,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.step.ended";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly finish: string;
@@ -4796,11 +4708,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4808,6 +4715,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.step.failed";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly error: {
@@ -4820,11 +4732,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4832,6 +4739,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.text.started";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly textID: string;
@@ -4841,11 +4753,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4853,6 +4760,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.text.ended";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly textID: string;
@@ -4863,11 +4775,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4875,6 +4782,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.reasoning.started";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly reasoningID: string;
@@ -4889,11 +4801,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4901,6 +4808,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.reasoning.ended";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly reasoningID: string;
@@ -4916,11 +4828,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4928,6 +4835,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.tool.input.started";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly name: string;
         readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -4938,11 +4850,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4950,6 +4857,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.tool.input.ended";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly text: string;
         readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -4960,11 +4872,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -4972,6 +4879,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.tool.called";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly tool: string;
         readonly input: {
@@ -4993,11 +4905,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -5005,6 +4912,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.tool.progress";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly structured: {
             readonly [x: string]: unknown;
@@ -5026,11 +4938,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -5038,6 +4945,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.tool.success";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly structured: {
             readonly [x: string]: unknown;
@@ -5069,11 +4981,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -5081,6 +4988,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.tool.failed";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly error: {
             readonly type: "unknown";
@@ -5103,11 +5015,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -5115,6 +5022,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.retried";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly attempt: number;
         readonly error: {
@@ -5135,11 +5047,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -5147,6 +5054,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.compaction.started";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly reason: "auto" | "manual";
@@ -5156,11 +5068,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -5168,6 +5075,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.compaction.ended";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly reason: "auto" | "manual";
@@ -5179,11 +5091,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -5191,6 +5098,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.revert.staged";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly revert: {
             readonly messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -5211,11 +5123,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -5223,6 +5130,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.revert.cleared";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly timestamp: import("effect/DateTime").Utc;
         readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
@@ -5230,11 +5142,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
@@ -5242,6 +5149,11 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
 } | {
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly type: "session.next.revert.committed";
+    readonly durable: {
+        readonly aggregateID: string;
+        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
+        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
+    };
     readonly data: {
         readonly messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
         readonly timestamp: import("effect/DateTime").Utc;
@@ -5250,11 +5162,6 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
     readonly metadata?: {
         readonly [x: string]: unknown;
     } | undefined;
-    readonly durable?: {
-        readonly aggregateID: string;
-        readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
-        readonly version: number & import("effect/Brand").Brand<"Event.Version">;
-    } | undefined;
     readonly location?: {
         readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
         readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;