npm - @opencode-ai/schema - Versions diffs - 0.0.0-dev-17872 → 0.0.0-dev-17880 - Mend

@opencode-ai/schema 0.0.0-dev-17872 → 0.0.0-dev-17880

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

package/dist/event-manifest.d.ts +140 -0
package/dist/instruction-entry.d.ts +6 -0
package/dist/instruction-entry.js +4 -0
package/dist/session-event.d.ts +362 -0
package/dist/session-event.js +12 -1
package/dist/session-transfer.d.ts +3 -0
package/dist/session.d.ts +4 -0
package/dist/session.js +4 -0
package/package.json +1 -1

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

@@ -727,6 +727,58 @@ 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.viewed">;
+    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 idle: Schema.Finite;
+        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.viewed";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
+    data: Schema.Struct<{
+        readonly idle: Schema.Finite;
+        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">;
@@ -893,6 +945,15 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
             };
         }>]>;
         readonly instructions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>>, Schema.optionalKey<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>, never, never>;
+        readonly instructionEntries: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>, 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">;
@@ -924,6 +985,15 @@ export declare const ServerDefinitions: readonly [Schema.Struct<{
             };
         }>]>;
         readonly instructions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>>, Schema.optionalKey<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>, never, never>;
+        readonly instructionEntries: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>, 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">;
@@ -6149,6 +6219,58 @@ 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.viewed">;
+    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 idle: Schema.Finite;
+        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.viewed";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
+    data: Schema.Struct<{
+        readonly idle: Schema.Finite;
+        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">;
@@ -6315,6 +6437,15 @@ export declare const Definitions: readonly [Schema.Struct<{
             };
         }>]>;
         readonly instructions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>>, Schema.optionalKey<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>, never, never>;
+        readonly instructionEntries: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>, 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">;
@@ -6346,6 +6477,15 @@ export declare const Definitions: readonly [Schema.Struct<{
             };
         }>]>;
         readonly instructions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>>, Schema.optionalKey<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>, never, never>;
+        readonly instructionEntries: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>, 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">;

package/dist/instruction-entry.d.ts CHANGED Viewed

@@ -13,6 +13,12 @@ export declare const Info: Schema.Struct<{
 }>;
 export interface Info extends Schema.Schema.Type<typeof Info> {
 }
+export declare const Snapshot: Schema.$Array<Schema.Struct<{
+    readonly removed: Schema.Boolean;
+    readonly key: Schema.String;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>>;
+export type Snapshot = typeof Snapshot.Type;
 export declare const MaxValueBytes: number;
 declare const ValueTooLargeError_base: Schema.Class<ValueTooLargeError, Schema.TaggedStruct<"InstructionEntryValueTooLargeError", {
     readonly actualBytes: Schema.Int;

package/dist/instruction-entry.js CHANGED Viewed

@@ -13,6 +13,10 @@ export const Info = Schema.Struct({
     key: Key,
     value: Schema.Json.annotate({ description: "JSON value attached to the session's instructions" }),
 }).annotate({ identifier: "InstructionEntry.Info" });
+export const Snapshot = Schema.Array(Schema.Struct({
+    ...Info.fields,
+    removed: Schema.Boolean,
+})).annotate({ identifier: "InstructionEntry.Snapshot" });
 export const MaxValueBytes = 8 * 1024;
 export class ValueTooLargeError extends Schema.TaggedError()("InstructionEntryValueTooLargeError", {
     actualBytes: Schema.Int,

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

@@ -580,6 +580,62 @@ export declare const Renamed: Schema.Struct<{
     }>;
 };
 export type Renamed = typeof Renamed.Type;
+export declare const Viewed: 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.viewed">;
+    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<{
+        /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
+        readonly idle: Schema.Finite;
+        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.viewed";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
+    data: Schema.Struct<{
+        /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
+        readonly idle: Schema.Finite;
+        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 Viewed = typeof Viewed.Type;
 export declare const UsageRecorded: Schema.Struct<{
     readonly id: Schema.brand<Schema.String, "Event.ID"> & {
         create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -828,6 +884,15 @@ export declare const Forked: Schema.Struct<{
             };
         }>]>;
         readonly instructions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>>, Schema.optionalKey<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>, never, never>;
+        readonly instructionEntries: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>, 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">;
@@ -859,6 +924,15 @@ export declare const Forked: Schema.Struct<{
             };
         }>]>;
         readonly instructions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>>, Schema.optionalKey<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>, never, never>;
+        readonly instructionEntries: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>, 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">;
@@ -4344,6 +4418,60 @@ 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.viewed">;
+    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<{
+        /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
+        readonly idle: Schema.Finite;
+        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.viewed";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
+    data: Schema.Struct<{
+        /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
+        readonly idle: Schema.Finite;
+        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">;
@@ -4510,6 +4638,15 @@ export declare const Definitions: readonly [Schema.Struct<{
             };
         }>]>;
         readonly instructions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>>, Schema.optionalKey<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>, never, never>;
+        readonly instructionEntries: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>, 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">;
@@ -4541,6 +4678,15 @@ export declare const Definitions: readonly [Schema.Struct<{
             };
         }>]>;
         readonly instructions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>>, Schema.optionalKey<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>, never, never>;
+        readonly instructionEntries: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>, 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">;
@@ -7927,6 +8073,60 @@ 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.viewed">;
+    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<{
+        /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
+        readonly idle: Schema.Finite;
+        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.viewed";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
+    data: Schema.Struct<{
+        /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
+        readonly idle: Schema.Finite;
+        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">;
@@ -8027,6 +8227,15 @@ export declare const DurableDefinitions: readonly [...((Schema.Struct<{
             };
         }>]>;
         readonly instructions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>>, Schema.optionalKey<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>, never, never>;
+        readonly instructionEntries: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>, 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">;
@@ -8058,6 +8267,15 @@ export declare const DurableDefinitions: readonly [...((Schema.Struct<{
             };
         }>]>;
         readonly instructions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>>, Schema.optionalKey<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>, never, never>;
+        readonly instructionEntries: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>, 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">;
@@ -11587,6 +11805,60 @@ 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.viewed">;
+    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<{
+        /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
+        readonly idle: Schema.Finite;
+        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.viewed";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
+    data: Schema.Struct<{
+        /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
+        readonly idle: Schema.Finite;
+        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">;
@@ -11687,6 +11959,15 @@ export declare const Durable: Schema.Union<readonly [...((Schema.Struct<{
             };
         }>]>;
         readonly instructions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>>, Schema.optionalKey<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>, never, never>;
+        readonly instructionEntries: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>, 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">;
@@ -11718,6 +11999,15 @@ export declare const Durable: Schema.Union<readonly [...((Schema.Struct<{
             };
         }>]>;
         readonly instructions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>>, Schema.optionalKey<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>, never, never>;
+        readonly instructionEntries: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>, 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">;
@@ -14921,6 +15211,60 @@ 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.viewed">;
+    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<{
+        /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
+        readonly idle: Schema.Finite;
+        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.viewed";
+    durability: "durable";
+    durable: {
+        readonly version: number;
+        readonly aggregate: string;
+    };
+    data: Schema.Struct<{
+        /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
+        readonly idle: Schema.Finite;
+        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">;
@@ -15021,6 +15365,15 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
             };
         }>]>;
         readonly instructions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>>, Schema.optionalKey<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>, never, never>;
+        readonly instructionEntries: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>, 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">;
@@ -15052,6 +15405,15 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
             };
         }>]>;
         readonly instructions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>>, Schema.optionalKey<Schema.$Record<Schema.brand<Schema.String, "Instruction.Key">, Schema.brand<Schema.String, "Instruction.Hash">>>, never, never>;
+        readonly instructionEntries: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly removed: Schema.Boolean;
+            readonly key: Schema.String;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>, 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">;

package/dist/session-event.js CHANGED Viewed

@@ -14,6 +14,7 @@ import { Revert } from "./session-revert.js";
 import { Shell as ShellSchema } from "./shell.js";
 import { SessionError } from "./session-error.js";
 import { Instruction } from "./instruction.js";
+import { InstructionEntry } from "./instruction-entry.js";
 import { Agent } from "./agent.js";
 import { Skill as SkillSchema } from "./skill.js";
 import { Money } from "./money.js";
@@ -89,6 +90,15 @@ export const Renamed = Event.durable({
         title: Schema.String,
     },
 });
+export const Viewed = Event.durable({
+    type: "session.viewed",
+    ...options,
+    schema: {
+        ...Base,
+        /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
+        idle: Schema.Finite,
+    },
+});
 export const UsageRecorded = Event.durable({
     type: "session.usage.recorded",
     ...options,
@@ -126,6 +136,7 @@ export const Forked = Event.durable({
         parentID: SessionID,
         boundary: SessionFork.Boundary,
         instructions: Instruction.Values.pipe(optional),
+        instructionEntries: InstructionEntry.Snapshot.pipe(optional),
     },
 });
 const InboxRef = {
@@ -494,7 +505,7 @@ export var RevertEvent;
         schema: { ...Base, to: SessionMessage.ID },
     });
 })(RevertEvent || (RevertEvent = {}));
-export const Definitions = Event.inventory(Created, AgentSelected, ModelSelected, Moved, Renamed, 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.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, 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.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);
 // UsageRecorded is durable but internal: excluded from Definitions so it never reaches the public manifest.
 export const DurableDefinitions = Event.inventory(...Definitions.filter((definition) => definition.durability === "durable"), UsageRecorded);
 export const EphemeralDefinitions = Event.inventory(...Definitions.filter((definition) => definition.durability === "ephemeral"));

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

@@ -113,9 +113,12 @@ export declare const Data: Schema.Struct<{
                 readonly write: Schema.Finite;
             }>;
         }>;
+        readonly outcome: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>>>, Schema.optionalKey<Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>>, never, never>;
         readonly time: Schema.Struct<{
             readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
             readonly updated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+            readonly idle: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
+            readonly viewed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
             readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
         }>;
         readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;

package/dist/session.d.ts CHANGED Viewed

@@ -147,9 +147,13 @@ export declare const Info: Schema.Struct<{
             readonly write: Schema.Finite;
         }>;
     }>;
+    /** Outcome of the last completed execution, recorded at `time.idle`. Absent until a run reaches a terminal transition. */
+    readonly outcome: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>>>, Schema.optionalKey<Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>>, never, never>;
     readonly time: Schema.Struct<{
         readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
         readonly updated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
+        readonly idle: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
+        readonly viewed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
         readonly archived: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
     }>;
     readonly title: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;

package/dist/session.js CHANGED Viewed

@@ -28,9 +28,13 @@ export const Info = Schema.Struct({
     model: Model.Ref.pipe(optional),
     cost: Money.USD,
     tokens: TokenUsage.Info,
+    /** Outcome of the last completed execution, recorded at `time.idle`. Absent until a run reaches a terminal transition. */
+    outcome: Schema.Literals(["succeeded", "failed", "interrupted"]).pipe(optional),
     time: Schema.Struct({
         created: DateTimeUtcFromMillis,
         updated: DateTimeUtcFromMillis,
+        idle: DateTimeUtcFromMillis.pipe(optional),
+        viewed: DateTimeUtcFromMillis.pipe(optional),
         archived: DateTimeUtcFromMillis.pipe(optional),
     }),
     title: Schema.String.pipe(optional),

package/package.json CHANGED Viewed

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