@kilocode/schema 0.0.0-stage → 0.0.0-v2-9

package/dist/config/provider.js

@@ -0,0 +1,109 @@
+export * as ConfigProvider from "./provider.js";
+import { Schema } from "effect";
+import { Money } from "../money.js";
+import { Capabilities, Compatibility, Family, ID, VariantID } from "../model.js";
+import { ProviderCompatibility } from "../model-compatibility.js";
+import { Provider } from "../provider.js";
+import { optional } from "../schema.js";
+export const Settings = Schema.StructWithRest(Schema.Struct({
+    timeout: Schema.Union([Schema.Finite, Schema.Literal(false)]).pipe(optional),
+    headerTimeout: Schema.Union([Schema.Finite, Schema.Literal(false)]).pipe(optional),
+    chunkTimeout: Schema.Union([Schema.Finite, Schema.Literal(false)]).pipe(optional),
+    compaction: Provider.Compaction.pipe(optional),
+    transport: Provider.Transport.pipe(optional),
+    encoding: Provider.Encoding.pipe(optional),
+}), [Schema.Record(Schema.String, Schema.UndefinedOr(Schema.Json))]).annotate({ identifier: "Config.Provider.Settings" });
+export const ModelSettings = Schema.StructWithRest(Schema.Struct({
+    compaction: Provider.Compaction.pipe(optional),
+    encoding: Provider.Encoding.pipe(optional),
+}), [Schema.Record(Schema.String, Schema.UndefinedOr(Schema.Json))]).annotate({ identifier: "Config.Model.Settings" });
+const JsonRecord = Schema.Record(Schema.String, Schema.Json);
+export const Overlays = {
+    settings: Settings.pipe(optional),
+    headers: Schema.Record(Schema.String, Schema.String).pipe(optional),
+    body: JsonRecord.pipe(optional),
+};
+const ModelOverlays = {
+    settings: ModelSettings.pipe(optional),
+    headers: Schema.Record(Schema.String, Schema.String).pipe(optional),
+    body: JsonRecord.pipe(optional),
+};
+export class Request extends Schema.Class("Config.Provider.Request")({
+    headers: Overlays.headers,
+    body: Overlays.body,
+}) {
+}
+class Cache extends Schema.Class("Config.Model.Cost.Cache")({
+    read: Money.USDPerMillionTokens.pipe(optional),
+    write: Money.USDPerMillionTokens.pipe(optional),
+}) {
+}
+class Cost extends Schema.Class("Config.Model.Cost")({
+    tier: Schema.Struct({
+        type: Schema.Literal("context"),
+        size: Schema.Int,
+    }).pipe(optional),
+    input: Money.USDPerMillionTokens,
+    output: Money.USDPerMillionTokens,
+    cache: Cache.pipe(optional),
+}) {
+}
+class Limit extends Schema.Class("Config.Model.Limit")({
+    context: Schema.Int.pipe(optional),
+    input: Schema.Int.pipe(optional),
+    output: Schema.Int.pipe(optional),
+}) {
+}
+// models.dev v2's `capabilities.reasoning`. OpenCode builds the model's variants from it; no control means none.
+export const Reasoning = Schema.Union([
+    Schema.Struct({ supported: Schema.Literal(false) }),
+    Schema.Struct({
+        supported: Schema.Literal(true),
+        toggle: Schema.Boolean.pipe(optional),
+        effort: Schema.String.pipe(Schema.Array, optional),
+        budget: Schema.Struct({
+            min: Schema.Int.pipe(optional),
+            max: Schema.Int.pipe(optional),
+        }).pipe(optional),
+    }),
+]).annotate({ identifier: "Config.Model.Reasoning" });
+class Model extends Schema.Class("Config.Model")({
+    modelID: ID.pipe(optional),
+    family: Family.pipe(optional),
+    name: Schema.String.pipe(optional),
+    releaseDate: Schema.String.check(Schema.isPattern(/^\d{4}-\d{2}(-\d{2})?$/u))
+        .annotate({ description: "Release date as YYYY-MM-DD or YYYY-MM" })
+        .pipe(optional),
+    compatibility: Compatibility.pipe(optional),
+    package: Schema.String.pipe(optional),
+    ...ModelOverlays,
+    // Partial: unset fields fall back to the base model's capabilities, then the defaults.
+    capabilities: Capabilities.mapFields((fields) => ({
+        tools: optional(fields.tools),
+        input: optional(fields.input),
+        output: optional(fields.output),
+        temperature: fields.temperature,
+        reasoning: Reasoning.pipe(optional),
+    }))
+        .annotate({ identifier: "Config.Model.Capabilities" })
+        .pipe(optional),
+    variants: Schema.Struct({
+        id: VariantID,
+        ...ModelOverlays,
+    }).pipe(Schema.Array, optional),
+    cost: Schema.Union([Cost, Cost.pipe(Schema.Array)]).pipe(optional),
+    disabled: Schema.Boolean.pipe(optional),
+    limit: Limit.pipe(optional),
+}) {
+}
+export class Info extends Schema.Class("Config.Provider")({
+    canonical: Provider.ID.pipe(optional),
+    name: Schema.String.pipe(optional),
+    env: Schema.String.pipe(Schema.Array, optional),
+    package: Schema.String.pipe(optional),
+    // Defaults for every model of this provider; model compatibility overrides individual fields.
+    compatibility: ProviderCompatibility.pipe(optional),
+    ...Overlays,
+    models: Schema.Record(Schema.String, Model).pipe(optional),
+}) {
+}

package/dist/config/reference.d.ts

@@ -0,0 +1,21 @@
+export * as ConfigReference from "./reference.js";
+import { Schema } from "effect";
+declare const Git_base: Schema.Class<Git, Schema.Struct<{
+    readonly repository: Schema.String;
+    readonly branch: 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 hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>, {}>;
+export declare class Git extends Git_base {
+}
+declare const Local_base: Schema.Class<Local, Schema.Struct<{
+    readonly path: Schema.String;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly hidden: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>, {}>;
+export declare class Local extends Local_base {
+}
+export declare const Entry: Schema.Union<readonly [Schema.String, typeof Git, typeof Local]>;
+export type Entry = typeof Entry.Type;
+export declare const Info: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, typeof Git, typeof Local]>>;
+export type Info = typeof Info.Type;

package/dist/config/reference.js

@@ -0,0 +1,18 @@
+export * as ConfigReference from "./reference.js";
+import { Schema } from "effect";
+import { optional } from "../schema.js";
+export class Git extends Schema.Class("Config.Reference.Git")({
+    repository: Schema.String,
+    branch: Schema.String.pipe(optional),
+    description: Schema.String.pipe(optional),
+    hidden: Schema.Boolean.pipe(optional),
+}) {
+}
+export class Local extends Schema.Class("Config.Reference.Local")({
+    path: Schema.String,
+    description: Schema.String.pipe(optional),
+    hidden: Schema.Boolean.pipe(optional),
+}) {
+}
+export const Entry = Schema.Union([Schema.String, Git, Local]);
+export const Info = Schema.Record(Schema.String, Entry);

package/dist/config/shell.d.ts

@@ -0,0 +1,9 @@
+export * as ConfigShell from "./shell.js";
+import { Schema } from "effect";
+export declare const Option: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly name: Schema.String;
+    readonly acceptable: Schema.Boolean;
+}>;
+export interface Option extends Schema.Schema.Type<typeof Option> {
+}

package/dist/config/shell.js

@@ -0,0 +1,7 @@
+export * as ConfigShell from "./shell.js";
+import { Schema } from "effect";
+export const Option = Schema.Struct({
+    path: Schema.String,
+    name: Schema.String,
+    acceptable: Schema.Boolean,
+}).annotate({ identifier: "ConfigShell.Option" });

package/dist/config/tool-output.d.ts

@@ -0,0 +1,8 @@
+export * as ConfigToolOutput from "./tool-output.js";
+import { Schema } from "effect";
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly max_lines: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+    readonly max_bytes: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}

package/dist/config/tool-output.js

@@ -0,0 +1,8 @@
+export * as ConfigToolOutput from "./tool-output.js";
+import { Schema } from "effect";
+import { optional, PositiveInt } from "../schema.js";
+export class Info extends Schema.Class("Config.ToolOutput")({
+    max_lines: PositiveInt.pipe(optional),
+    max_bytes: PositiveInt.pipe(optional),
+}) {
+}

package/dist/config/warming.d.ts

@@ -0,0 +1,10 @@
+export * as ConfigWarming from "./warming.js";
+import { Schema } from "effect";
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly prompt: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly interval: Schema.decodeTo<Schema.optional<Schema.toType<Schema.DurationFromString>>, Schema.optionalKey<Schema.DurationFromString>, never, never>;
+    readonly duration: Schema.decodeTo<Schema.optional<Schema.toType<Schema.DurationFromString>>, Schema.optionalKey<Schema.DurationFromString>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}
+export declare const Warming: Schema.Union<readonly [Schema.Boolean, typeof Info]>;

package/dist/config/warming.js

@@ -0,0 +1,16 @@
+export * as ConfigWarming from "./warming.js";
+import { Schema } from "effect";
+import { optional } from "../schema.js";
+export class Info extends Schema.Class("Config.Warming")({
+    prompt: Schema.String.pipe(optional).annotate({
+        description: "Prompt sent for keep-alive requests",
+    }),
+    interval: Schema.DurationFromString.pipe(optional).annotate({
+        description: 'Idle time between keep-alive requests (default: "4 minutes")',
+    }),
+    duration: Schema.DurationFromString.pipe(optional).annotate({
+        description: 'Time after the last active request to keep a session warm (default: "30 minutes")',
+    }),
+}) {
+}
+export const Warming = Schema.Union([Schema.Boolean, Info]);

package/dist/config/watcher.d.ts

@@ -0,0 +1,7 @@
+export * as ConfigWatcher from "./watcher.js";
+import { Schema } from "effect";
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly ignore: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}

package/dist/config/watcher.js

@@ -0,0 +1,7 @@
+export * as ConfigWatcher from "./watcher.js";
+import { Schema } from "effect";
+import { optional } from "../schema.js";
+export class Info extends Schema.Class("Config.Watcher")({
+    ignore: Schema.String.pipe(Schema.Array, optional),
+}) {
+}

package/dist/config/websearch.d.ts

@@ -0,0 +1,9 @@
+export * as ConfigWebSearch from "./websearch.js";
+import { Schema } from "effect";
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly provider: Schema.Union<readonly [Schema.Literal<"random">, Schema.brand<Schema.String, "WebSearch.ID">]>;
+}>, {}>;
+export declare class Info extends Info_base {
+}
+export declare const Selection: Schema.Union<readonly [Schema.Literal<false>, typeof Info]>;
+export type Selection = typeof Selection.Type;

package/dist/config/websearch.js

@@ -0,0 +1,13 @@
+export * as ConfigWebSearch from "./websearch.js";
+import { Schema } from "effect";
+import { WebSearch } from "../websearch.js";
+export class Info extends Schema.Class("ConfigWebSearch.Info")({
+    provider: Schema.Union([
+        Schema.Literal("random").annotate({
+            description: "Reuse a randomly selected provider until it is rate limited, then switch to another available provider.",
+        }),
+        WebSearch.ID,
+    ]),
+}) {
+}
+export const Selection = Schema.Union([Schema.Literal(false), Info]);

package/dist/config/worktree.d.ts

@@ -0,0 +1,7 @@
+export * as ConfigWorktree from "./worktree.js";
+import { Schema } from "effect";
+export declare const Info: Schema.Struct<{
+    readonly directory: Schema.Trim;
+}>;
+export interface Info extends Schema.Schema.Type<typeof Info> {
+}

package/dist/config/worktree.js

@@ -0,0 +1,7 @@
+export * as ConfigWorktree from "./worktree.js";
+import { Schema } from "effect";
+export const Info = Schema.Struct({
+    directory: Schema.Trim.pipe(Schema.check(Schema.isNonEmpty())).annotate({
+        description: "Parent directory for new worktrees, relative to the project's primary checkout when not absolute",
+    }),
+}).annotate({ identifier: "Config.Worktree" });

package/dist/config.d.ts

@@ -0,0 +1,182 @@
+export * as Config from "./config.js";
+import { Schema } from "effect";
+import { ConfigAgent } from "./config/agent.js";
+import { ConfigMedia } from "./config/media.js";
+import { ConfigCompaction } from "./config/compaction.js";
+import { ConfigCommand } from "./config/command.js";
+import { ConfigExperimental } from "./config/experimental.js";
+import { ConfigFormatter } from "./config/formatter.js";
+import { ConfigLSP } from "./config/lsp.js";
+import { ConfigMCP } from "./config/mcp.js";
+import { ConfigPlugin } from "./config/plugin.js";
+import { ConfigProvider } from "./config/provider.js";
+import { ConfigReference } from "./config/reference.js";
+import { ConfigWebSearch } from "./config/websearch.js";
+import { ConfigToolOutput } from "./config/tool-output.js";
+import { ConfigWatcher } from "./config/watcher.js";
+import { ConfigWarming } from "./config/warming.js";
+declare const Info_base: Schema.Class<Info, Schema.Struct<{
+    readonly $schema: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly shell: 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 default_agent: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly update: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["disable", "notify", "auto"]>>>, Schema.optionalKey<Schema.Literals<readonly ["disable", "notify", "auto"]>>, never, never>;
+    readonly share: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["manual", "auto", "disabled"]>>>, Schema.optionalKey<Schema.Literals<readonly ["manual", "auto", "disabled"]>>, never, never>;
+    readonly enterprise: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    }>>, never, never>;
+    readonly username: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly action: Schema.String;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly action: Schema.String;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
+    }>>>, never, never>;
+    readonly policies: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
+        readonly action: Schema.Literals<readonly ["provider.use", "tool.use", "integration.use"]>;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny"]>;
+    }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly action: Schema.Literals<readonly ["provider.use", "tool.use", "integration.use"]>;
+        readonly resource: Schema.String;
+        readonly effect: Schema.Literals<readonly ["allow", "deny"]>;
+    }>>>, never, never>;
+    readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, typeof ConfigAgent.Info>>>, Schema.optionalKey<Schema.$Record<Schema.String, typeof ConfigAgent.Info>>, never, never>;
+    readonly snapshots: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly watcher: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigWatcher.Info>>, Schema.optionalKey<typeof ConfigWatcher.Info>, never, never>;
+    readonly formatter: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Boolean, Schema.$Record<Schema.String, typeof ConfigFormatter.Entry>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.$Record<Schema.String, typeof ConfigFormatter.Entry>]>>, never, never>;
+    readonly lsp: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Boolean, Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly disabled: Schema.Literal<true>;
+    }>, typeof ConfigLSP.Server]>>]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Struct<{
+        readonly disabled: Schema.Literal<true>;
+    }>, typeof ConfigLSP.Server]>>]>>, never, never>;
+    readonly media: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigMedia.Info>>, Schema.optionalKey<typeof ConfigMedia.Info>, never, never>;
+    readonly tool_output: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigToolOutput.Info>>, Schema.optionalKey<typeof ConfigToolOutput.Info>, never, never>;
+    readonly mcp: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigMCP.Info>>, Schema.optionalKey<typeof ConfigMCP.Info>, never, never>;
+    readonly compaction: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigCompaction.Info>>, Schema.optionalKey<typeof ConfigCompaction.Info>, never, never>;
+    readonly skills: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly commands: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, typeof ConfigCommand.Info>>>, Schema.optionalKey<Schema.$Record<Schema.String, typeof ConfigCommand.Info>>, never, never>;
+    readonly instructions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    readonly references: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, typeof ConfigReference.Git, typeof ConfigReference.Local]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, typeof ConfigReference.Git, typeof ConfigReference.Local]>>>, never, never>;
+    readonly websearch: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Literal<false>, typeof ConfigWebSearch.Info]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Literal<false>, typeof ConfigWebSearch.Info]>>, never, never>;
+    readonly plugins: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Union<readonly [Schema.String, typeof ConfigPlugin.Entry]>>>>, Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.String, typeof ConfigPlugin.Entry]>>>, never, never>;
+    readonly worktree: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
+        readonly directory: Schema.Trim;
+    }>>>, Schema.optionalKey<Schema.Struct<{
+        readonly directory: Schema.Trim;
+    }>>, never, never>;
+    readonly warming: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Union<readonly [Schema.Boolean, typeof ConfigWarming.Info]>>>, Schema.optionalKey<Schema.Union<readonly [Schema.Boolean, typeof ConfigWarming.Info]>>, never, never>;
+    readonly providers: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, typeof ConfigProvider.Info>>>, Schema.optionalKey<Schema.$Record<Schema.String, typeof ConfigProvider.Info>>, never, never>;
+    readonly experimental: Schema.decodeTo<Schema.optional<Schema.toType<typeof ConfigExperimental.Info>>, Schema.optionalKey<typeof ConfigExperimental.Info>, never, never>;
+}>, {}>;
+export declare class Info extends Info_base {
+}
+export declare const Patch: Schema.Struct<{
+    readonly shell: Schema.NullOr<Schema.String>;
+}>;
+export interface Patch extends Schema.Schema.Type<typeof Patch> {
+}
+declare const Document_base: Schema.Class<Document, Schema.Struct<{
+    readonly type: Schema.Literal<"document">;
+    readonly path: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "AbsolutePath">>>, Schema.optionalKey<Schema.brand<Schema.String, "AbsolutePath">>, never, never>;
+    readonly info: typeof Info;
+}>, {}>;
+export declare class Document extends Document_base {
+}
+declare const Directory_base: Schema.Class<Directory, Schema.Struct<{
+    readonly type: Schema.Literal<"directory">;
+    readonly path: Schema.brand<Schema.String, "AbsolutePath">;
+}>, {}>;
+export declare class Directory extends Directory_base {
+}
+export declare const Entry: Schema.Union<readonly [typeof Document, typeof Directory]>;
+export type Entry = typeof Entry.Type;
+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<"config.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: "config.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<"config.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: "config.updated";
+        durability: "ephemeral";
+        durable: undefined;
+        data: Schema.Struct<{}>;
+    }];
+};

package/dist/config.js

@@ -0,0 +1,135 @@
+export * as Config from "./config.js";
+import { Schema } from "effect";
+import { ephemeral, inventory } from "./event.js";
+import { Permission } from "./permission.js";
+import { AbsolutePath, optional } from "./schema.js";
+import { ConfigAgent } from "./config/agent.js";
+import { ConfigMedia } from "./config/media.js";
+import { ConfigCompaction } from "./config/compaction.js";
+import { ConfigCommand } from "./config/command.js";
+import { ConfigExperimental } from "./config/experimental.js";
+import { ConfigFormatter } from "./config/formatter.js";
+import { ConfigLSP } from "./config/lsp.js";
+import { ConfigMCP } from "./config/mcp.js";
+import { ConfigModel } from "./config/model.js";
+import { ConfigPlugin } from "./config/plugin.js";
+import { ConfigPolicy } from "./config/policy.js";
+import { ConfigProvider } from "./config/provider.js";
+import { ConfigReference } from "./config/reference.js";
+import { ConfigWebSearch } from "./config/websearch.js";
+import { ConfigToolOutput } from "./config/tool-output.js";
+import { ConfigWatcher } from "./config/watcher.js";
+import { ConfigWarming } from "./config/warming.js";
+import { ConfigWorktree } from "./config/worktree.js";
+export class Info extends Schema.Class("Config.Info")({
+    $schema: optional(Schema.String).annotate({
+        description: "JSON schema reference for configuration validation",
+    }),
+    shell: Schema.String.pipe(optional).annotate({
+        description: "Default shell to use for terminal and shell tool execution",
+    }),
+    model: ConfigModel.Selection.pipe(optional).annotate({
+        description: "Default model to use when no session or agent model is selected",
+    }),
+    default_agent: Schema.String.pipe(optional).annotate({
+        description: "Default primary agent to use when no session agent is selected",
+    }),
+    update: Schema.Literals(["disable", "notify", "auto"]).pipe(optional).annotate({
+        description: "Disable updates, notify when one is available, or install updates automatically",
+    }),
+    share: Schema.Literals(["manual", "auto", "disabled"]).pipe(optional).annotate({
+        description: "Control whether sessions may be shared manually, automatically, or not at all",
+    }),
+    enterprise: Schema.Struct({
+        url: Schema.String.pipe(optional),
+    })
+        .pipe(optional)
+        .annotate({
+        description: "Enterprise sharing service configuration",
+    }),
+    username: Schema.String.pipe(optional).annotate({
+        description: "Username displayed in conversations and used for telemetry identity",
+    }),
+    permissions: Permission.Ruleset.pipe(optional).annotate({
+        description: "Ordered tool permission rules applied to agent tool use",
+    }),
+    policies: ConfigPolicy.Info.pipe(Schema.Array, optional).annotate({
+        description: "Ordered policies controlling access to providers, tools, and integrations",
+    }),
+    agents: Schema.Record(Schema.String, ConfigAgent.Info).pipe(optional).annotate({
+        description: "Named built-in agent overrides and custom agent definitions",
+    }),
+    snapshots: Schema.Boolean.pipe(optional).annotate({
+        description: "Enable snapshots used for undo and revert behavior",
+    }),
+    watcher: ConfigWatcher.Info.pipe(optional).annotate({
+        description: "Filesystem watcher configuration",
+    }),
+    formatter: ConfigFormatter.Info.pipe(optional).annotate({
+        description: "Enable built-in formatters or configure formatter overrides",
+    }),
+    lsp: ConfigLSP.Info.pipe(optional).annotate({
+        description: "Enable built-in language servers or configure server overrides",
+    }),
+    media: ConfigMedia.Info.pipe(optional).annotate({
+        description: "Media processing configuration",
+    }),
+    tool_output: ConfigToolOutput.Info.pipe(optional).annotate({
+        description: "Tool output truncation thresholds",
+    }),
+    mcp: ConfigMCP.Info.pipe(optional).annotate({
+        description: "MCP server configuration",
+    }),
+    compaction: ConfigCompaction.Info.pipe(optional).annotate({
+        description: "Conversation compaction behavior",
+    }),
+    skills: Schema.String.pipe(Schema.Array, optional).annotate({
+        description: "Additional paths or URLs to discover skills from",
+    }),
+    commands: Schema.Record(Schema.String, ConfigCommand.Info).pipe(optional).annotate({
+        description: "Named slash command definitions",
+    }),
+    instructions: Schema.String.pipe(Schema.Array, optional).annotate({
+        description: "Additional paths or URLs supplying ambient instructions",
+    }),
+    references: ConfigReference.Info.pipe(optional).annotate({
+        description: "Named local directories or Git repositories available as external context",
+    }),
+    websearch: ConfigWebSearch.Selection.pipe(optional).annotate({
+        description: "Web search provider selection",
+    }),
+    plugins: ConfigPlugin.Plugins.pipe(optional).annotate({
+        description: "Ordered plugin enablement directives and external package declarations",
+    }),
+    worktree: ConfigWorktree.Info.pipe(optional).annotate({
+        description: "Directory defaults for local worktree creation",
+    }),
+    warming: ConfigWarming.Warming.pipe(optional).annotate({
+        description: "Keep recently active sessions warm with transient model requests (default: false)",
+    }),
+    providers: Schema.Record(Schema.String, ConfigProvider.Info).pipe(optional),
+    experimental: ConfigExperimental.Info.pipe(optional),
+}) {
+}
+export const Patch = Schema.Struct({
+    shell: Schema.NullOr(Schema.String),
+}).annotate({ identifier: "Config.Patch" });
+export class Document extends Schema.Class("Config.Document")({
+    type: Schema.Literal("document"),
+    path: AbsolutePath.pipe(optional),
+    info: Info,
+}) {
+}
+export class Directory extends Schema.Class("Config.Directory")({
+    type: Schema.Literal("directory"),
+    path: AbsolutePath,
+}) {
+}
+export const Entry = Schema.Union([Document, Directory]).annotate({
+    identifier: "Config.Entry",
+});
+const Updated = ephemeral({
+    type: "config.updated",
+    schema: {},
+});
+export const Event = { Updated, Definitions: inventory(Updated) };