@opencode/schema 0.0.0-reserved → 2.0.1

package/dist/agent.d.ts

@@ -0,0 +1,164 @@
+export * as Agent from "./agent.js";
+import { Schema } from "effect";
+export declare const ID: Schema.brand<Schema.String, "Agent.ID">;
+export type ID = typeof ID.Type;
+export declare const Name: Schema.brand<Schema.String, "Agent.Name">;
+export type Name = typeof Name.Type;
+export declare const Color: Schema.String;
+export type Color = typeof Color.Type;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const Info: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "Agent.ID">;
+    readonly name: Schema.brand<Schema.String, "Agent.Name">;
+    readonly model: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Model.ID">;
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+            opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+            anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+            openai: string & import("effect/Brand").Brand<"Provider.ID">;
+            google: string & import("effect/Brand").Brand<"Provider.ID">;
+            googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+            githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+            amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+            azure: string & import("effect/Brand").Brand<"Provider.ID">;
+            openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+            mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+            gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+        };
+        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+    }> & {
+        parse: (input: string) => {
+            readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+            readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+            readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
+        };
+    }>>, Schema.optionalKey<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "Model.ID">;
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID"> & {
+            opencode: string & import("effect/Brand").Brand<"Provider.ID">;
+            anthropic: string & import("effect/Brand").Brand<"Provider.ID">;
+            openai: string & import("effect/Brand").Brand<"Provider.ID">;
+            google: string & import("effect/Brand").Brand<"Provider.ID">;
+            googleVertex: string & import("effect/Brand").Brand<"Provider.ID">;
+            githubCopilot: string & import("effect/Brand").Brand<"Provider.ID">;
+            amazonBedrock: string & import("effect/Brand").Brand<"Provider.ID">;
+            azure: string & import("effect/Brand").Brand<"Provider.ID">;
+            openrouter: string & import("effect/Brand").Brand<"Provider.ID">;
+            mistral: string & import("effect/Brand").Brand<"Provider.ID">;
+            gitlab: string & import("effect/Brand").Brand<"Provider.ID">;
+        };
+        readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
+    }> & {
+        parse: (input: string) => {
+            readonly id: string & import("effect/Brand").Brand<"Model.ID">;
+            readonly providerID: string & import("effect/Brand").Brand<"Provider.ID">;
+            readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
+        };
+    }>, never, never>;
+    readonly request: Schema.Struct<{
+        readonly settings: Schema.withConstructorDefault<Schema.$Record<Schema.String, Schema.Any>>;
+        readonly headers: Schema.$Record<Schema.String, Schema.String>;
+        readonly body: Schema.$Record<Schema.String, Schema.Any>;
+    }>;
+    readonly system: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly mode: Schema.Literals<readonly ["subagent", "primary", "all"]>;
+    readonly hidden: Schema.Boolean;
+    readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly steps: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly permissions: Schema.$Array<Schema.Struct<{
+        readonly action: Schema.String;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    }>>;
+}> & {
+    default: (id: ID) => {
+        id: string & import("effect/Brand").Brand<"Agent.ID">;
+        name: string & import("effect/Brand").Brand<"Agent.Name">;
+        request: {
+            settings: {};
+            headers: {};
+            body: {};
+        };
+        mode: "primary";
+        hidden: false;
+        permissions: ({
+            action: string;
+            resource: string;
+            effect: "allow";
+        } | {
+            action: string;
+            resource: string;
+            effect: "ask";
+        })[];
+    };
+};
+export declare const Event: {
+    Updated: 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<"agent.updated">;
+        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<{}>;
+    }> & {
+        type: "agent.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
+    };
+    Definitions: readonly [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<"agent.updated">;
+        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<{}>;
+    }> & {
+        type: "agent.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
+    }];
+};

package/dist/agent.js

@@ -0,0 +1,46 @@
+export * as Agent from "./agent.js";
+import { Schema } from "effect";
+import { ephemeral, inventory } from "./event.js";
+import { optional } from "./schema.js";
+import { Model } from "./model.js";
+import { Permission } from "./permission.js";
+import { Provider } from "./provider.js";
+import { PositiveInt, statics } from "./schema.js";
+const Updated = ephemeral({ type: "agent.updated", schema: {} });
+export const ID = Schema.String.pipe(Schema.brand("Agent.ID"));
+export const Name = Schema.String.pipe(Schema.brand("Agent.Name"));
+export const Color = Schema.String.annotate({ identifier: "Agent.Color" });
+export const Info = Schema.Struct({
+    id: ID,
+    name: Name,
+    model: Model.Ref.pipe(optional),
+    request: Provider.Request,
+    system: Schema.String.pipe(optional),
+    description: Schema.String.pipe(optional),
+    mode: Schema.Literals(["subagent", "primary", "all"]),
+    hidden: Schema.Boolean,
+    color: Color.pipe(optional),
+    steps: PositiveInt.pipe(optional),
+    permissions: Permission.Ruleset,
+})
+    .annotate({ identifier: "Agent.Info" })
+    .pipe(statics(() => ({
+    default: (id) => ({
+        id,
+        name: Name.make(id),
+        request: { settings: {}, headers: {}, body: {} },
+        mode: "primary",
+        hidden: false,
+        permissions: [
+            { action: "*", resource: "*", effect: "allow" },
+            { action: "external_directory", resource: "*", effect: "ask" },
+            { action: "read", resource: "*.env", effect: "ask" },
+            { action: "read", resource: "*.env.*", effect: "ask" },
+            { action: "read", resource: "*.env.example", effect: "allow" },
+        ],
+    }),
+})));
+export const Event = {
+    Updated,
+    Definitions: inventory(Updated),
+};

package/dist/catalog.d.ts

@@ -0,0 +1,69 @@
+export * as Catalog from "./catalog.js";
+export declare const Event: {
+    Updated: import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: import("effect/Schema").Finite;
+        readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+        readonly type: import("effect/Schema").Literal<"catalog.updated">;
+        readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/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: import("effect/Schema").Struct<{}>;
+    }> & {
+        type: "catalog.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: import("effect/Schema").Struct<{}>;
+    };
+    Definitions: readonly [import("effect/Schema").Struct<{
+        readonly id: import("effect/Schema").brand<import("effect/Schema").String, "Event.ID"> & {
+            create: () => string & import("effect/Brand").Brand<"Event.ID">;
+        };
+        readonly created: import("effect/Schema").Finite;
+        readonly metadata: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>>, import("effect/Schema").optionalKey<import("effect/Schema").$Record<import("effect/Schema").String, import("effect/Schema").Unknown>>, never, never>;
+        readonly type: import("effect/Schema").Literal<"catalog.updated">;
+        readonly location: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").Struct<{
+            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>, never, never>;
+        }>>>, import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+            readonly directory: import("effect/Schema").brand<import("effect/Schema").String, "AbsolutePath">;
+            readonly workspaceID: import("effect/Schema").decodeTo<import("effect/Schema").optional<import("effect/Schema").toType<import("effect/Schema").brand<import("effect/Schema").String, "Workspace.ID"> & {
+                ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
+                create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
+            }>>, import("effect/Schema").optionalKey<import("effect/Schema").brand<import("effect/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: import("effect/Schema").Struct<{}>;
+    }> & {
+        type: "catalog.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: import("effect/Schema").Struct<{}>;
+    }];
+};

package/dist/catalog.js

@@ -0,0 +1,4 @@
+export * as Catalog from "./catalog.js";
+import { ephemeral, inventory } from "./event.js";
+const Updated = ephemeral({ type: "catalog.updated", schema: {} });
+export const Event = { Updated, Definitions: inventory(Updated) };

package/dist/command.d.ts

@@ -0,0 +1,76 @@
+export * as Command from "./command.js";
+import { Schema } from "effect";
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}
+export declare const Info: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+}>;
+export declare const Event: {
+    Updated: 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<"command.updated">;
+        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<{}>;
+    }> & {
+        type: "command.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
+    };
+    Definitions: readonly [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<"command.updated">;
+        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<{}>;
+    }> & {
+        type: "command.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
+    }];
+};

package/dist/command.js

@@ -0,0 +1,13 @@
+export * as Command from "./command.js";
+import { Schema } from "effect";
+import { ephemeral, inventory } from "./event.js";
+import { optional } from "./schema.js";
+const Updated = ephemeral({ type: "command.updated", schema: {} });
+export const Info = Schema.Struct({
+    name: Schema.String,
+    description: Schema.String.pipe(optional),
+}).annotate({ identifier: "Command.Info" });
+export const Event = {
+    Updated,
+    Definitions: inventory(Updated),
+};

package/dist/config/agent.d.ts

@@ -0,0 +1,42 @@
+export * as ConfigAgent from "./agent.js";
+import { Schema } from "effect";
+import { ConfigProvider } from "./provider.js";
+export declare const Color: Schema.String;
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly model: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.Struct<{
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID">;
+        readonly model: Schema.brand<Schema.String, "Model.ID">;
+        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.Union<readonly [Schema.String, Schema.Struct<{
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID">;
+        readonly model: Schema.brand<Schema.String, "Model.ID">;
+        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>>>, Schema.optionalKey<Schema.decodeTo<Schema.Struct<{
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID">;
+        readonly model: Schema.brand<Schema.String, "Model.ID">;
+        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.Union<readonly [Schema.String, Schema.Struct<{
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID">;
+        readonly model: Schema.brand<Schema.String, "Model.ID">;
+        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>>, never, never>;
+    readonly request: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigProvider.Request>>, Schema.optionalKey<typeof ConfigProvider.Request>, never, never>;
+    readonly system: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly mode: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["subagent", "primary", "all"]>>>, Schema.optionalKey<Schema.Literals<readonly ["subagent", "primary", "all"]>>, never, never>;
+    readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly color: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly steps: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly disabled: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, 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>;
+}>, {}>;
+export declare class Info extends Info_base {
+}

package/dist/config/agent.js

@@ -0,0 +1,20 @@
+export * as ConfigAgent from "./agent.js";
+import { Schema } from "effect";
+import { Permission } from "../permission.js";
+import { optional, PositiveInt } from "../schema.js";
+import { ConfigModel } from "./model.js";
+import { ConfigProvider } from "./provider.js";
+export const Color = Schema.String.check(Schema.isPattern(/^#[0-9a-fA-F]{6}$/));
+export class Info extends Schema.Class("Config.Agent")({
+    model: ConfigModel.Selection.pipe(optional),
+    request: ConfigProvider.Request.pipe(optional),
+    system: Schema.String.pipe(optional),
+    description: Schema.String.pipe(optional),
+    mode: Schema.Literals(["subagent", "primary", "all"]).pipe(optional),
+    hidden: Schema.Boolean.pipe(optional),
+    color: Color.pipe(optional),
+    steps: PositiveInt.pipe(optional),
+    disabled: Schema.Boolean.pipe(optional),
+    permissions: Permission.Ruleset.pipe(optional),
+}) {
+}

package/dist/config/command.d.ts

@@ -0,0 +1,28 @@
+export * as ConfigCommand from "./command.js";
+import { Schema } from "effect";
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly template: Schema.String;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly agent: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly model: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.Struct<{
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID">;
+        readonly model: Schema.brand<Schema.String, "Model.ID">;
+        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.Union<readonly [Schema.String, Schema.Struct<{
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID">;
+        readonly model: Schema.brand<Schema.String, "Model.ID">;
+        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>>>, Schema.optionalKey<Schema.decodeTo<Schema.Struct<{
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID">;
+        readonly model: Schema.brand<Schema.String, "Model.ID">;
+        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.Union<readonly [Schema.String, Schema.Struct<{
+        readonly providerID: Schema.brand<Schema.String, "Provider.ID">;
+        readonly model: Schema.brand<Schema.String, "Model.ID">;
+        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>>, never, never>;
+    readonly subagent: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly subtask: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}

package/dist/config/command.js

@@ -0,0 +1,13 @@
+export * as ConfigCommand from "./command.js";
+import { Schema } from "effect";
+import { optional } from "../schema.js";
+import { ConfigModel } from "./model.js";
+export class Info extends Schema.Class("Config.Command")({
+    template: Schema.String,
+    description: Schema.String.pipe(optional),
+    agent: Schema.String.pipe(optional),
+    model: ConfigModel.Selection.pipe(optional),
+    subagent: Schema.Boolean.pipe(optional),
+    subtask: Schema.Boolean.annotate({ description: "Deprecated alias for subagent." }).pipe(optional),
+}) {
+}

package/dist/config/compaction.d.ts

@@ -0,0 +1,14 @@
+export * as ConfigCompaction from "./compaction.js";
+import { Schema } from "effect";
+declare const Keep_base: Schema.Class<Keep, Schema.Struct<{
+    readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+}>, {}>;
+export declare class Keep extends Keep_base {
+}
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly auto: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly keep: Schema.decodeTo<Schema.optional<Schema.toType<typeof Keep>>, Schema.optionalKey<typeof Keep>, never, never>;
+    readonly buffer: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}

package/dist/config/compaction.js

@@ -0,0 +1,13 @@
+export * as ConfigCompaction from "./compaction.js";
+import { Schema } from "effect";
+import { NonNegativeInt, optional } from "../schema.js";
+export class Keep extends Schema.Class("Config.Compaction.Keep")({
+    tokens: NonNegativeInt.pipe(optional),
+}) {
+}
+export class Info extends Schema.Class("Config.Compaction")({
+    auto: Schema.Boolean.pipe(optional),
+    keep: Keep.pipe(optional),
+    buffer: NonNegativeInt.pipe(optional),
+}) {
+}

package/dist/config/experimental.d.ts

@@ -0,0 +1,17 @@
+export * as ConfigExperimental from "./experimental.js";
+import { Schema } from "effect";
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly portable_shell_scanner: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly subagent_depth: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly policies: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly action: Schema.Literal<"provider.use">;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny"]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly action: Schema.Literal<"provider.use">;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny"]>;
+    }>>>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}

package/dist/config/experimental.js

@@ -0,0 +1,16 @@
+export * as ConfigExperimental from "./experimental.js";
+import { Schema } from "effect";
+import { NonNegativeInt, optional } from "../schema.js";
+import { ConfigPolicy } from "./policy.js";
+export class Info extends Schema.Class("ConfigExperimental.Info")({
+    portable_shell_scanner: Schema.Boolean.pipe(optional).annotate({
+        description: "Enable the experimental portable shell permission scanner. Defaults to false.",
+    }),
+    subagent_depth: NonNegativeInt.pipe(optional).annotate({
+        description: "Maximum subagent nesting depth. Defaults to 1.",
+    }),
+    policies: ConfigPolicy.Info.pipe(Schema.Array, optional).annotate({
+        description: "Ordered policies controlling access to configured resources",
+    }),
+}) {
+}

package/dist/config/formatter.d.ts

@@ -0,0 +1,11 @@
+export * as ConfigFormatter from "./formatter.js";
+import { Schema } from "effect";
+declare const Entry_base: Schema.Class<Entry, Schema.Struct<{
+    readonly disabled: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly command: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly environment: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+    readonly extensions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+}>, {}>;
+export declare class Entry extends Entry_base {
+}
+export declare const Info: Schema.Union<readonly [Schema.Boolean, Schema.$Record<Schema.String, typeof Entry>]>;

package/dist/config/formatter.js

@@ -0,0 +1,11 @@
+export * as ConfigFormatter from "./formatter.js";
+import { Schema } from "effect";
+import { optional } from "../schema.js";
+export class Entry extends Schema.Class("Config.Formatter.Entry")({
+    disabled: Schema.Boolean.pipe(optional),
+    command: Schema.String.pipe(Schema.Array, optional),
+    environment: Schema.Record(Schema.String, Schema.String).pipe(optional),
+    extensions: Schema.String.pipe(Schema.Array, optional),
+}) {
+}
+export const Info = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry)]);

package/dist/config/lsp.d.ts

@@ -0,0 +1,20 @@
+export * as ConfigLSP from "./lsp.js";
+import { Schema } from "effect";
+export declare const Disabled: Schema.Struct<{
+    readonly disabled: Schema.Literal<true>;
+}>;
+declare const Server_base: Schema.Class<Server, Schema.Struct<{
+    readonly command: Schema.$Array<Schema.String>;
+    readonly extensions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly disabled: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly env: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+    readonly initialization: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
+}>, {}>;
+export declare class Server extends Server_base {
+}
+export declare const Entry: Schema.Union<readonly [Schema.Struct<{
+    readonly disabled: Schema.Literal<true>;
+}>, typeof Server]>;
+export declare const Info: Schema.Union<readonly [Schema.Boolean, Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+    readonly disabled: Schema.Literal<true>;
+}>, typeof Server]>>]>;

package/dist/config/lsp.js

@@ -0,0 +1,16 @@
+export * as ConfigLSP from "./lsp.js";
+import { Schema } from "effect";
+import { optional } from "../schema.js";
+export const Disabled = Schema.Struct({
+    disabled: Schema.Literal(true),
+});
+export class Server extends Schema.Class("Config.LSP.Server")({
+    command: Schema.String.pipe(Schema.Array),
+    extensions: Schema.String.pipe(Schema.Array, optional),
+    disabled: Schema.Boolean.pipe(optional),
+    env: Schema.Record(Schema.String, Schema.String).pipe(optional),
+    initialization: Schema.Record(Schema.String, Schema.Unknown).pipe(optional),
+}) {
+}
+export const Entry = Schema.Union([Disabled, Server]);
+export const Info = Schema.Union([Schema.Boolean, Schema.Record(Schema.String, Entry)]);