@opencode-ai/schema 0.0.0-next-15090 → 0.0.0-next-15092

package/dist/session.d.ts

@@ -2,12 +2,14 @@ export * as Session from "./session.js";
 import { Schema } from "effect";
 import { SessionEvent } from "./session-event.js";
 import { SessionID } from "./session-id.js";
+import { Revert } from "./session-revert.js";
 export declare const ID: Schema.brand<Schema.String, "SessionID"> & {
     create: () => string & import("effect/Brand").Brand<"SessionID">;
     descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
 };
 export type ID = SessionID;
 export declare const Event: typeof SessionEvent;
+export { Revert };
 export interface Info extends Schema.Schema.Type<typeof Info> {
 }
 export declare const Info: Schema.Struct<{
@@ -27,6 +29,7 @@ export declare const Info: Schema.Struct<{
             create: () => string & import("effect/Brand").Brand<"SessionID">;
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
+        /** Messages before this exclusive boundary are copied into the fork. */
         readonly messageID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
             fromEvent: (eventID: import("./event.js").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -39,6 +42,7 @@ export declare const Info: Schema.Struct<{
             create: () => string & import("effect/Brand").Brand<"SessionID">;
             descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
         };
+        /** Messages before this exclusive boundary are copied into the fork. */
         readonly messageID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Session.Message.ID"> & {
             create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
             fromEvent: (eventID: import("./event.js").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -50,9 +54,9 @@ export declare const Info: Schema.Struct<{
     readonly projectID: Schema.brand<Schema.String, "Project.ID"> & {
         global: string & import("effect/Brand").Brand<"Project.ID">;
     };
-    readonly agent: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "AgentV2.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "AgentV2.ID">>, never, never>;
+    readonly agent: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Agent.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Agent.ID">>, never, never>;
     readonly model: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
+        readonly id: Schema.brand<Schema.String, "Model.ID">;
         readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
             opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
             anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
@@ -66,9 +70,9 @@ export declare const Info: Schema.Struct<{
             mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
             gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
         };
-        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "VariantID">>, never, never>;
+        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
     }>>>, Schema.optionalKey<Schema.Struct<{
-        readonly id: Schema.brand<Schema.String, "ModelV2.ID">;
+        readonly id: Schema.brand<Schema.String, "Model.ID">;
         readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
             opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
             anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
@@ -82,9 +86,11 @@ export declare const Info: Schema.Struct<{
             mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
             gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
         };
-        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "VariantID">>, never, never>;
+        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
     }>>, never, never>;
-    readonly cost: Schema.Finite;
+    readonly cost: Schema.brand<Schema.Finite, "Money.USD"> & {
+        zero: number & import("effect/Brand").Brand<"Money.USD">;
+    };
     readonly tokens: Schema.Struct<{
         readonly input: Schema.Finite;
         readonly output: Schema.Finite;
@@ -117,20 +123,19 @@ export declare const Info: Schema.Struct<{
             fromEvent: (eventID: import("./event.js").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
         readonly partID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly snapshot: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly diff: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly snapshot: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Snapshot.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Snapshot.ID">>, never, never>;
         readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-            readonly path: Schema.brand<Schema.String, "RelativePath">;
-            readonly status: Schema.Literals<readonly ["added", "modified", "deleted"]>;
+            readonly file: Schema.String;
+            readonly patch: Schema.String;
             readonly additions: Schema.Int;
             readonly deletions: Schema.Int;
-            readonly patch: Schema.String;
+            readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
         }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly path: Schema.brand<Schema.String, "RelativePath">;
-            readonly status: Schema.Literals<readonly ["added", "modified", "deleted"]>;
+            readonly file: Schema.String;
+            readonly patch: Schema.String;
             readonly additions: Schema.Int;
             readonly deletions: Schema.Int;
-            readonly patch: Schema.String;
+            readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
         }>>>, never, never>;
     }>>>, Schema.optionalKey<Schema.Struct<{
         readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
@@ -138,20 +143,19 @@ export declare const Info: Schema.Struct<{
             fromEvent: (eventID: import("./event.js").ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
         };
         readonly partID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly snapshot: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
-        readonly diff: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly snapshot: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Snapshot.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Snapshot.ID">>, never, never>;
         readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
-            readonly path: Schema.brand<Schema.String, "RelativePath">;
-            readonly status: Schema.Literals<readonly ["added", "modified", "deleted"]>;
+            readonly file: Schema.String;
+            readonly patch: Schema.String;
             readonly additions: Schema.Int;
             readonly deletions: Schema.Int;
-            readonly patch: Schema.String;
+            readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
         }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
-            readonly path: Schema.brand<Schema.String, "RelativePath">;
-            readonly status: Schema.Literals<readonly ["added", "modified", "deleted"]>;
+            readonly file: Schema.String;
+            readonly patch: Schema.String;
             readonly additions: Schema.Int;
             readonly deletions: Schema.Int;
-            readonly patch: Schema.String;
+            readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
         }>>>, never, never>;
     }>>, never, never>;
 }>;

package/dist/session.js

@@ -8,29 +8,25 @@ import { DateTimeUtcFromMillis, optional, RelativePath } from "./schema.js";
 import { SessionEvent } from "./session-event.js";
 import { SessionID } from "./session-id.js";
 import { SessionMessage } from "./session-message.js";
-import { Revert } from "./revert.js";
+import { Money } from "./money.js";
+import { TokenUsage } from "./token-usage.js";
+import { Revert } from "./session-revert.js";
 export const ID = SessionID;
 export const Event = SessionEvent;
+export { Revert };
 export const Info = Schema.Struct({
     id: ID,
     parentID: ID.pipe(optional),
     fork: Schema.Struct({
         sessionID: ID,
+        /** Messages before this exclusive boundary are copied into the fork. */
         messageID: SessionMessage.ID.pipe(optional),
     }).pipe(optional),
     projectID: Project.ID,
     agent: Agent.ID.pipe(optional),
     model: Model.Ref.pipe(optional),
-    cost: Schema.Finite,
-    tokens: Schema.Struct({
-        input: Schema.Finite,
-        output: Schema.Finite,
-        reasoning: Schema.Finite,
-        cache: Schema.Struct({
-            read: Schema.Finite,
-            write: Schema.Finite,
-        }),
-    }),
+    cost: Money.USD,
+    tokens: TokenUsage.Info,
     time: Schema.Struct({
         created: DateTimeUtcFromMillis,
         updated: DateTimeUtcFromMillis,
@@ -39,8 +35,8 @@ export const Info = Schema.Struct({
     title: Schema.String,
     location: Location.Ref,
     subpath: RelativePath.pipe(optional),
-    revert: Revert.State.pipe(optional),
-}).annotate({ identifier: "SessionV2.Info" });
+    revert: Revert.pipe(optional),
+}).annotate({ identifier: "Session.Info" });
 export const ListAnchor = Schema.Struct({
     id: ID,
     time: Schema.Finite,

package/dist/shell.d.ts

@@ -1,8 +1,8 @@
 export * as Shell from "./shell.js";
 import { Schema } from "effect";
-export declare const ID: Schema.brand<Schema.String, "ShellID"> & {
-    create: () => string & import("effect/Brand").Brand<"ShellID">;
-    ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+export declare const ID: Schema.brand<Schema.String, "Shell.ID"> & {
+    create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+    ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
 };
 export type ID = typeof ID.Type;
 export declare const Status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
@@ -16,9 +16,9 @@ export interface Time extends Schema.Schema.Type<typeof Time> {
 export declare const Metadata: Schema.$Record<Schema.String, Schema.Unknown>;
 export type Metadata = typeof Metadata.Type;
 export declare const Info: Schema.Struct<{
-    readonly id: Schema.brand<Schema.String, "ShellID"> & {
-        create: () => string & import("effect/Brand").Brand<"ShellID">;
-        ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+    readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+        ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
     };
     readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
     readonly command: Schema.String;
@@ -64,9 +64,9 @@ export declare const Event: {
         }>>, never, never>;
         readonly data: Schema.Struct<{
             readonly info: Schema.Struct<{
-                readonly id: Schema.brand<Schema.String, "ShellID"> & {
-                    create: () => string & import("effect/Brand").Brand<"ShellID">;
-                    ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+                readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
+                    create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+                    ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
                 };
                 readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
                 readonly command: Schema.String;
@@ -88,9 +88,9 @@ export declare const Event: {
         durable: undefined;
         data: Schema.Struct<{
             readonly info: Schema.Struct<{
-                readonly id: Schema.brand<Schema.String, "ShellID"> & {
-                    create: () => string & import("effect/Brand").Brand<"ShellID">;
-                    ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+                readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
+                    create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+                    ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
                 };
                 readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
                 readonly command: Schema.String;
@@ -134,9 +134,9 @@ export declare const Event: {
             }>, never, never>;
         }>>, never, never>;
         readonly data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "ShellID"> & {
-                create: () => string & import("effect/Brand").Brand<"ShellID">;
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+            readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
             };
             readonly exit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
             readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
@@ -146,9 +146,9 @@ export declare const Event: {
         durability: "ephemeral";
         durable: undefined;
         data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "ShellID"> & {
-                create: () => string & import("effect/Brand").Brand<"ShellID">;
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+            readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
             };
             readonly exit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
             readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
@@ -181,9 +181,9 @@ export declare const Event: {
             }>, never, never>;
         }>>, never, never>;
         readonly data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "ShellID"> & {
-                create: () => string & import("effect/Brand").Brand<"ShellID">;
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+            readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
             };
         }>;
     }> & {
@@ -191,9 +191,9 @@ export declare const Event: {
         durability: "ephemeral";
         durable: undefined;
         data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "ShellID"> & {
-                create: () => string & import("effect/Brand").Brand<"ShellID">;
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+            readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
             };
         }>;
     };
@@ -225,9 +225,9 @@ export declare const Event: {
         }>>, never, never>;
         readonly data: Schema.Struct<{
             readonly info: Schema.Struct<{
-                readonly id: Schema.brand<Schema.String, "ShellID"> & {
-                    create: () => string & import("effect/Brand").Brand<"ShellID">;
-                    ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+                readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
+                    create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+                    ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
                 };
                 readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
                 readonly command: Schema.String;
@@ -249,9 +249,9 @@ export declare const Event: {
         durable: undefined;
         data: Schema.Struct<{
             readonly info: Schema.Struct<{
-                readonly id: Schema.brand<Schema.String, "ShellID"> & {
-                    create: () => string & import("effect/Brand").Brand<"ShellID">;
-                    ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+                readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
+                    create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+                    ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
                 };
                 readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
                 readonly command: Schema.String;
@@ -294,9 +294,9 @@ export declare const Event: {
             }>, never, never>;
         }>>, never, never>;
         readonly data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "ShellID"> & {
-                create: () => string & import("effect/Brand").Brand<"ShellID">;
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+            readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
             };
             readonly exit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
             readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
@@ -306,9 +306,9 @@ export declare const Event: {
         durability: "ephemeral";
         durable: undefined;
         data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "ShellID"> & {
-                create: () => string & import("effect/Brand").Brand<"ShellID">;
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+            readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
             };
             readonly exit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Number>>, Schema.optionalKey<Schema.Number>, never, never>;
             readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
@@ -340,9 +340,9 @@ export declare const Event: {
             }>, never, never>;
         }>>, never, never>;
         readonly data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "ShellID"> & {
-                create: () => string & import("effect/Brand").Brand<"ShellID">;
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+            readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
             };
         }>;
     }> & {
@@ -350,9 +350,9 @@ export declare const Event: {
         durability: "ephemeral";
         durable: undefined;
         data: Schema.Struct<{
-            readonly id: Schema.brand<Schema.String, "ShellID"> & {
-                create: () => string & import("effect/Brand").Brand<"ShellID">;
-                ascending: (id?: string) => string & import("effect/Brand").Brand<"ShellID">;
+            readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
+                create: () => string & import("effect/Brand").Brand<"Shell.ID">;
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
             };
         }>;
     }];

package/dist/shell.js

@@ -4,7 +4,7 @@ import { optional } from "./schema.js";
 import { ephemeral, inventory } from "./event.js";
 import { ascending } from "./identifier.js";
 import { NonNegativeInt, statics } from "./schema.js";
-const IDSchema = Schema.String.check(Schema.isStartsWith("sh_")).pipe(Schema.brand("ShellID"));
+const IDSchema = Schema.String.check(Schema.isStartsWith("sh_")).pipe(Schema.brand("Shell.ID"));
 export const ID = IDSchema.pipe(statics((schema) => {
     const create = () => schema.make("sh_" + ascending());
     return {

package/dist/skill.d.ts

@@ -1,21 +1,26 @@
 export * as Skill from "./skill.js";
 import { Schema } from "effect";
+export declare const ID: Schema.brand<Schema.String, "Skill.ID">;
+export type ID = typeof ID.Type;
+export declare const Name: Schema.brand<Schema.String, "Skill.Name">;
+export type Name = typeof Name.Type;
 export interface DirectorySource extends Schema.Schema.Type<typeof DirectorySource> {
 }
 export declare const DirectorySource: Schema.Struct<{
-    readonly type: Schema.Literal<"directory">;
+    readonly type: Schema.tag<"directory">;
     readonly path: Schema.brand<Schema.String, "AbsolutePath">;
 }>;
 export interface UrlSource extends Schema.Schema.Type<typeof UrlSource> {
 }
 export declare const UrlSource: Schema.Struct<{
-    readonly type: Schema.Literal<"url">;
+    readonly type: Schema.tag<"url">;
     readonly url: Schema.String;
 }>;
 export interface Info extends Schema.Schema.Type<typeof Info> {
 }
 export declare const Info: Schema.Struct<{
-    readonly name: Schema.String;
+    readonly id: Schema.brand<Schema.String, "Skill.ID">;
+    readonly name: Schema.brand<Schema.String, "Skill.Name">;
     readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
     readonly slash: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
     readonly autoinvoke: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
@@ -93,9 +98,10 @@ export declare const Event: {
 export interface EmbeddedSource extends Schema.Schema.Type<typeof EmbeddedSource> {
 }
 export declare const EmbeddedSource: Schema.Struct<{
-    readonly type: Schema.Literal<"embedded">;
+    readonly type: Schema.tag<"embedded">;
     readonly skill: Schema.suspend<Schema.Struct<{
-        readonly name: Schema.String;
+        readonly id: Schema.brand<Schema.String, "Skill.ID">;
+        readonly name: Schema.brand<Schema.String, "Skill.Name">;
         readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly slash: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly autoinvoke: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
@@ -105,15 +111,16 @@ export declare const EmbeddedSource: Schema.Struct<{
 }>;
 export type Source = DirectorySource | UrlSource | EmbeddedSource;
 export declare const Source: Schema.Union<readonly [Schema.Struct<{
-    readonly type: Schema.Literal<"directory">;
+    readonly type: Schema.tag<"directory">;
     readonly path: Schema.brand<Schema.String, "AbsolutePath">;
 }>, Schema.Struct<{
-    readonly type: Schema.Literal<"url">;
+    readonly type: Schema.tag<"url">;
     readonly url: Schema.String;
 }>, Schema.Struct<{
-    readonly type: Schema.Literal<"embedded">;
+    readonly type: Schema.tag<"embedded">;
     readonly skill: Schema.suspend<Schema.Struct<{
-        readonly name: Schema.String;
+        readonly id: Schema.brand<Schema.String, "Skill.ID">;
+        readonly name: Schema.brand<Schema.String, "Skill.Name">;
         readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
         readonly slash: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
         readonly autoinvoke: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;

package/dist/skill.js

@@ -3,29 +3,32 @@ import { Schema } from "effect";
 import { optional } from "./schema.js";
 import { AbsolutePath } from "./schema.js";
 import { ephemeral, inventory } from "./event.js";
+export const ID = Schema.String.pipe(Schema.brand("Skill.ID"));
+export const Name = Schema.String.pipe(Schema.brand("Skill.Name"));
 export const DirectorySource = Schema.Struct({
-    type: Schema.Literal("directory"),
+    type: Schema.tag("directory"),
     path: AbsolutePath,
-}).annotate({ identifier: "SkillV2.DirectorySource" });
+}).annotate({ identifier: "Skill.DirectorySource" });
 export const UrlSource = Schema.Struct({
-    type: Schema.Literal("url"),
+    type: Schema.tag("url"),
     url: Schema.String,
-}).annotate({ identifier: "SkillV2.UrlSource" });
+}).annotate({ identifier: "Skill.UrlSource" });
 export const Info = Schema.Struct({
-    name: Schema.String,
+    id: ID,
+    name: Name,
     description: Schema.String.pipe(optional),
     slash: Schema.Boolean.pipe(optional),
     autoinvoke: Schema.Boolean.pipe(optional),
     location: AbsolutePath,
     content: Schema.String,
-}).annotate({ identifier: "SkillV2.Info" });
+}).annotate({ identifier: "Skill.Info" });
 const Updated = ephemeral({ type: "skill.updated", schema: {} });
 export const Event = { Updated, Definitions: inventory(Updated) };
 export const EmbeddedSource = Schema.Struct({
-    type: Schema.Literal("embedded"),
+    type: Schema.tag("embedded"),
     skill: Schema.suspend(() => Info),
-}).annotate({ identifier: "SkillV2.EmbeddedSource" });
-export const Source = Object.assign(Schema.Union([DirectorySource, UrlSource, EmbeddedSource]).pipe(Schema.toTaggedUnion("type"), Schema.annotate({ identifier: "SkillV2.Source" })), {
+}).annotate({ identifier: "Skill.EmbeddedSource" });
+export const Source = Object.assign(Schema.Union([DirectorySource, UrlSource, EmbeddedSource]).pipe(Schema.toTaggedUnion("type"), Schema.annotate({ identifier: "Skill.Source" })), {
     equals: (a, b) => {
         if (a.type !== b.type)
             return false;
@@ -34,12 +37,12 @@ export const Source = Object.assign(Schema.Union([DirectorySource, UrlSource, Em
         if (a.type === "url" && b.type === "url")
             return a.url === b.url;
         if (a.type === "embedded" && b.type === "embedded")
-            return a.skill.name === b.skill.name;
+            return a.skill.id === b.skill.id;
         return false;
     },
     key: (source) => source.type === "directory"
         ? `directory:${source.path}`
         : source.type === "url"
             ? `url:${source.url}`
-            : `embedded:${source.skill.name}`,
+            : `embedded:${source.skill.id}`,
 });

package/dist/snapshot.d.ts

@@ -0,0 +1,4 @@
+export * as Snapshot from "./snapshot.js";
+import { Schema } from "effect";
+export declare const ID: Schema.brand<Schema.String, "Snapshot.ID">;
+export type ID = typeof ID.Type;

package/dist/snapshot.js

@@ -0,0 +1,3 @@
+export * as Snapshot from "./snapshot.js";
+import { Schema } from "effect";
+export const ID = Schema.String.pipe(Schema.brand("Snapshot.ID"));

package/dist/token-usage.d.ts

@@ -0,0 +1,13 @@
+export * as TokenUsage from "./token-usage.js";
+import { Schema } from "effect";
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const Info: Schema.Struct<{
+    readonly input: Schema.Finite;
+    readonly output: Schema.Finite;
+    readonly reasoning: Schema.Finite;
+    readonly cache: Schema.Struct<{
+        readonly read: Schema.Finite;
+        readonly write: Schema.Finite;
+    }>;
+}>;

package/dist/token-usage.js

@@ -0,0 +1,11 @@
+export * as TokenUsage from "./token-usage.js";
+import { Schema } from "effect";
+export const Info = Schema.Struct({
+    input: Schema.Finite,
+    output: Schema.Finite,
+    reasoning: Schema.Finite,
+    cache: Schema.Struct({
+        read: Schema.Finite,
+        write: Schema.Finite,
+    }),
+}).annotate({ identifier: "TokenUsage.Info" });