npm - @opencode/schema - Versions diffs - 0.0.0-dev-19447 → 0.0.0-dev-19449 - Mend

@opencode/schema 0.0.0-dev-19447 → 0.0.0-dev-19449

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 (7) hide show

package/dist/event-manifest.d.ts +156 -0
package/dist/session-event.d.ts +392 -0
package/dist/session-event.js +11 -1
package/dist/session-transfer.d.ts +9 -0
package/dist/session.d.ts +10 -0
package/dist/session.js +3 -0
package/package.json +1 -1

package/dist/event-manifest.d.ts CHANGED Viewed

@@ -307,6 +307,15 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
             };
         }>, never, never>;
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+        readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>, never, never>;
         readonly version: Schema.String;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -391,6 +400,15 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
             };
         }>, never, never>;
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+        readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>, never, never>;
         readonly version: Schema.String;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -767,6 +785,66 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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.permissions.updated">;
+    readonly durable: Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, 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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+}> & {
+    type: "session.permissions.updated";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
+    data: Schema.Struct<{
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
 }, Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -6381,6 +6459,15 @@ export declare const Definitions: readonly [Schema.Struct<{
             };
         }>, never, never>;
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+        readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>, never, never>;
         readonly version: Schema.String;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -6465,6 +6552,15 @@ export declare const Definitions: readonly [Schema.Struct<{
             };
         }>, never, never>;
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+        readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>, never, never>;
         readonly version: Schema.String;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -6841,6 +6937,66 @@ export declare const Definitions: readonly [Schema.Struct<{
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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.permissions.updated">;
+    readonly durable: Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, 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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+}> & {
+    type: "session.permissions.updated";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
+    data: Schema.Struct<{
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
 }, Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;

package/dist/session-event.d.ts CHANGED Viewed

@@ -113,6 +113,15 @@ export declare const Created: Schema.Struct<{
         }>, never, never>;
         /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+        readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>, never, never>;
         readonly version: Schema.String;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -198,6 +207,15 @@ export declare const Created: Schema.Struct<{
         }>, never, never>;
         /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+        readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>, never, never>;
         readonly version: Schema.String;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -584,6 +602,68 @@ export declare const Renamed: Schema.Struct<{
     }>;
 };
 export type Renamed = typeof Renamed.Type;
+export declare const PermissionsUpdated: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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.permissions.updated">;
+    readonly durable: Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, 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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+}> & {
+    type: "session.permissions.updated";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
+    data: Schema.Struct<{
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+};
+export type PermissionsUpdated = typeof PermissionsUpdated.Type;
 export declare const Viewed: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -4514,6 +4594,15 @@ export declare const Definitions: readonly [Schema.Struct<{
         }>, never, never>;
         /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+        readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>, never, never>;
         readonly version: Schema.String;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -4599,6 +4688,15 @@ export declare const Definitions: readonly [Schema.Struct<{
         }>, never, never>;
         /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+        readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>, never, never>;
         readonly version: Schema.String;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -4975,6 +5073,66 @@ export declare const Definitions: readonly [Schema.Struct<{
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
+}, Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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.permissions.updated">;
+    readonly durable: Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, 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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+}> & {
+    type: "session.permissions.updated";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
+    data: Schema.Struct<{
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
 }, Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -8509,6 +8667,15 @@ export declare const DurableDefinitions: readonly [...((Schema.Struct<{
         }>, never, never>;
         /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+        readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>, never, never>;
         readonly version: Schema.String;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -8594,6 +8761,15 @@ export declare const DurableDefinitions: readonly [...((Schema.Struct<{
         }>, never, never>;
         /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+        readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>, never, never>;
         readonly version: Schema.String;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -8970,6 +9146,66 @@ export declare const DurableDefinitions: readonly [...((Schema.Struct<{
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
+}) | (Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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.permissions.updated">;
+    readonly durable: Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, 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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+}> & {
+    type: "session.permissions.updated";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
+    data: Schema.Struct<{
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
 }) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -12789,6 +13025,15 @@ export declare const Durable: Schema.Union<readonly [...((Schema.Struct<{
         }>, never, never>;
         /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+        readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>, never, never>;
         readonly version: Schema.String;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -12874,6 +13119,15 @@ export declare const Durable: Schema.Union<readonly [...((Schema.Struct<{
         }>, never, never>;
         /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+        readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>, never, never>;
         readonly version: Schema.String;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -13250,6 +13504,66 @@ export declare const Durable: Schema.Union<readonly [...((Schema.Struct<{
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
+}) | (Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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.permissions.updated">;
+    readonly durable: Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, 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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+}> & {
+    type: "session.permissions.updated";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
+    data: Schema.Struct<{
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
 }) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -16743,6 +17057,15 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
         }>, never, never>;
         /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+        readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>, never, never>;
         readonly version: Schema.String;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -16828,6 +17151,15 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
         }>, never, never>;
         /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+        readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>, never, never>;
         readonly version: Schema.String;
         readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
             create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -17204,6 +17536,66 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
     }>;
+}) | (Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly created: Schema.Finite;
+    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.permissions.updated">;
+    readonly durable: Schema.Struct<{
+        readonly aggregateID: Schema.String;
+        readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
+        readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, 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, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
+        readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
+            ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+            create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+        }>, never, never>;
+    }>>, never, never>;
+    readonly data: Schema.Struct<{
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
+}> & {
+    type: "session.permissions.updated";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
+    data: Schema.Struct<{
+        readonly permissions: Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>;
+        readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
+            create: () => string & import("effect/Brand").Brand<"SessionID">;
+            descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
+        };
+    }>;
 }) | (Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;

package/dist/session-event.js CHANGED Viewed

@@ -24,6 +24,7 @@ import { TokenUsage } from "./token-usage.js";
 import { SessionInbox } from "./session-inbox.js";
 import { Project } from "./project.js";
 import { SessionFork } from "./session-fork.js";
+import { Permission } from "./permission.js";
 export { FileAttachment };
 export const Source = Schema.Struct({
     start: NonNegativeInt,
@@ -56,6 +57,7 @@ export const Created = Event.durable({
         model: Model.Ref.pipe(optional),
         /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
         metadata: SessionMetadata.pipe(optional),
+        permissions: Permission.Ruleset.pipe(optional),
         version: Schema.String,
     },
 });
@@ -93,6 +95,14 @@ export const Renamed = Event.durable({
         title: Schema.String,
     },
 });
+export const PermissionsUpdated = Event.durable({
+    type: "session.permissions.updated",
+    ...options,
+    schema: {
+        ...Base,
+        permissions: Permission.Ruleset,
+    },
+});
 export const Viewed = Event.durable({
     type: "session.viewed",
     ...options,
@@ -537,7 +547,7 @@ export var RevertEvent;
         schema: { ...Base, to: SessionMessage.ID },
     });
 })(RevertEvent || (RevertEvent = {}));
-export const Definitions = Event.inventory(Created, AgentSelected, ModelSelected, Moved, Renamed, Viewed, UsageUpdated, Deleted, Forked, InboxDelivered, InboxEnqueued, InboxCancelled, InboxDeliveryChanged, Execution.Started, Execution.Succeeded, Execution.Failed, Execution.Interrupted, InstructionsUpdated, Synthetic, Skill.Activated, Shell.Started, Shell.Ended, Step.Started, Step.Streamed, Step.Ended, Step.Failed, Text.Started, Text.Delta, Text.Ended, Reasoning.Started, Reasoning.Delta, Reasoning.Ended, Tool.Input.Started, Tool.Input.Delta, Tool.Input.Ended, Tool.Called, Tool.Progress, Tool.Success, Tool.Failed, RetryScheduled, Compaction.Started, Compaction.Delta, Compaction.Ended, Compaction.Failed, RevertEvent.Staged, RevertEvent.Cleared, RevertEvent.Committed);
+export const Definitions = Event.inventory(Created, AgentSelected, ModelSelected, Moved, Renamed, PermissionsUpdated, Viewed, UsageUpdated, Deleted, Forked, InboxDelivered, InboxEnqueued, InboxCancelled, InboxDeliveryChanged, Execution.Started, Execution.Succeeded, Execution.Failed, Execution.Interrupted, InstructionsUpdated, Synthetic, Skill.Activated, Shell.Started, Shell.Ended, Step.Started, Step.Streamed, Step.Ended, Step.Failed, Text.Started, Text.Delta, Text.Ended, Reasoning.Started, Reasoning.Delta, Reasoning.Ended, Tool.Input.Started, Tool.Input.Delta, Tool.Input.Ended, Tool.Called, Tool.Progress, Tool.Success, Tool.Failed, RetryScheduled, Compaction.Started, Compaction.Delta, Compaction.Ended, Compaction.Failed, RevertEvent.Staged, RevertEvent.Cleared, RevertEvent.Committed);
 // Internal and replay-only events are excluded from the public manifest.
 export const DurableDefinitions = Event.inventory(...Definitions.filter((definition) => definition.durability === "durable"), UsageRecorded, MessageContentUpdated);
 export const EphemeralDefinitions = Event.inventory(...Definitions.filter((definition) => definition.durability === "ephemeral"));

package/dist/session-transfer.d.ts CHANGED Viewed

@@ -134,6 +134,15 @@ export declare const Data: Schema.Struct<{
         }>;
         readonly subpath: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "RelativePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "RelativePath">>, never, never>;
         readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+        readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly action: Schema.String;
+            readonly resource: Schema.String;
+            readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+        }>>>, never, never>;
         readonly revert: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
             readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
                 create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;

package/dist/session.d.ts CHANGED Viewed

@@ -172,6 +172,16 @@ export declare const Info: Schema.Struct<{
     }>;
     readonly subpath: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "RelativePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "RelativePath">>, never, never>;
     readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
+    /** Evaluated after the agent's rules; the last matching rule wins. */
+    readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly action: Schema.String;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly action: Schema.String;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    }>>>, never, never>;
     readonly revert: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
         readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;

package/dist/session.js CHANGED Viewed

@@ -9,6 +9,7 @@ import { SessionEvent } from "./session-event.js";
 import { SessionID } from "./session-id.js";
 import { SessionMetadata } from "./session-metadata.js";
 import { Money } from "./money.js";
+import { Permission } from "./permission.js";
 import { TokenUsage } from "./token-usage.js";
 import { Revert } from "./session-revert.js";
 import { SessionFork } from "./session-fork.js";
@@ -43,6 +44,8 @@ export const Info = Schema.Struct({
     location: Location.Ref,
     subpath: RelativePath.pipe(optional),
     metadata: Metadata.pipe(optional),
+    /** Evaluated after the agent's rules; the last matching rule wins. */
+    permissions: Permission.Ruleset.pipe(optional),
     revert: Revert.pipe(optional),
 }).annotate({ identifier: "Session.Info" });
 export const ListAnchor = Schema.Struct({

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/schema",
-  "version": "0.0.0-dev-19447",
+  "version": "0.0.0-dev-19449",
   "type": "module",
   "license": "MIT",
   "repository": {