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

package/dist/kilocode/marketplace.d.ts

@@ -0,0 +1,593 @@
+export * as KiloMarketplaceRpc from "./marketplace.js";
+import { Schema } from "effect";
+export declare const Kind: Schema.Literals<readonly ["skill", "mcp"]>;
+export type Kind = typeof Kind.Type;
+/** Install into the global config directory or the opened project. */
+export declare const Scope: Schema.Literals<readonly ["global", "project"]>;
+export type Scope = typeof Scope.Type;
+export declare const Parameter: Schema.Struct<{
+    readonly key: Schema.String;
+    readonly name: Schema.String;
+    readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly optional: Schema.Boolean;
+    /** Mask entry in clients; supplied values can still be stored as plaintext in MCP config. */
+    readonly secret: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+}>;
+export type Parameter = typeof Parameter.Type;
+export declare const InstallOption: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly prerequisites: Schema.$Array<Schema.String>;
+    readonly parameters: Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly name: Schema.String;
+        readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly optional: Schema.Boolean;
+        /** Mask entry in clients; supplied values can still be stored as plaintext in MCP config. */
+        readonly secret: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }>>;
+}>;
+export type InstallOption = typeof InstallOption.Type;
+export declare const Item: Schema.Struct<{
+    readonly registry: Schema.String;
+    readonly kind: Schema.Literals<readonly ["skill", "mcp"]>;
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly description: Schema.String;
+    readonly category: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly author: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly tags: Schema.$Array<Schema.String>;
+    readonly prerequisites: Schema.$Array<Schema.String>;
+    /** Parameters shared by every install option. */
+    readonly parameters: Schema.$Array<Schema.Struct<{
+        readonly key: Schema.String;
+        readonly name: Schema.String;
+        readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly optional: Schema.Boolean;
+        /** Mask entry in clients; supplied values can still be stored as plaintext in MCP config. */
+        readonly secret: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    }>>;
+    readonly options: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+        readonly prerequisites: Schema.$Array<Schema.String>;
+        readonly parameters: Schema.$Array<Schema.Struct<{
+            readonly key: Schema.String;
+            readonly name: Schema.String;
+            readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            readonly optional: Schema.Boolean;
+            /** Mask entry in clients; supplied values can still be stored as plaintext in MCP config. */
+            readonly secret: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+        }>>;
+    }>>;
+}>;
+export type Item = typeof Item.Type;
+/**
+ * Owned resources are located from the current scope, never from stored paths: a skill tree is
+ * `<skills root>/<id>` and an MCP entry is found by server name in the scope's native config files.
+ * During recovery both previous and planned contents may be owned.
+ */
+export declare const Resource: Schema.Union<readonly [Schema.Struct<{
+    readonly id: Schema.String;
+    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+}>, Schema.Struct<{
+    readonly server: Schema.String;
+    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+}>]>;
+export type Resource = typeof Resource.Type;
+/** A managed installation, authorizing removal of exactly the resources it wrote. */
+export declare const Installed: Schema.Struct<{
+    /** Stored record format; an unknown version is skipped instead of being misread. */
+    readonly version: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literal<1>>>, Schema.optionalKey<Schema.Literal<1>>, never, never>;
+    readonly registry: Schema.String;
+    readonly kind: Schema.Literals<readonly ["skill", "mcp"]>;
+    readonly id: Schema.String;
+    readonly scope: Schema.Literals<readonly ["global", "project"]>;
+    readonly project: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    /** MCP config file relative to the scope root, so records survive moving the project. */
+    readonly config: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    /** Native mcp.servers key, used for status and sign-in handoff. */
+    readonly server: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+    readonly resources: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly id: Schema.String;
+        readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    }>, Schema.Struct<{
+        readonly server: Schema.String;
+        readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    }>]>>>>, Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly id: Schema.String;
+        readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    }>, Schema.Struct<{
+        readonly server: Schema.String;
+        readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    }>]>>>, never, never>;
+    /** Intent persisted before mutations, recoverable by retry or uninstall. */
+    readonly recovering: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+    readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["ready", "missing", "modified", "incomplete"]>>>, Schema.optionalKey<Schema.Literals<readonly ["ready", "missing", "modified", "incomplete"]>>, never, never>;
+    readonly warnings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    /** Obsolete resources remain owned until cleanup succeeds. */
+    readonly pending: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly id: Schema.String;
+        readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    }>, Schema.Struct<{
+        readonly server: Schema.String;
+        readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    }>]>>>>, Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly id: Schema.String;
+        readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    }>, Schema.Struct<{
+        readonly server: Schema.String;
+        readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+    }>]>>>, never, never>;
+    readonly installedAt: Schema.Number;
+}>;
+export type Installed = typeof Installed.Type;
+export declare const Definition: {
+    readonly id: "kilocode.marketplace";
+    readonly methods: {
+        list: {
+            input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly kind: "mcp" | "skill";
+                readonly refresh?: boolean | undefined;
+                readonly query?: string | undefined;
+            }, {
+                readonly kind: "mcp" | "skill";
+                readonly refresh?: boolean | undefined;
+                readonly query?: string | undefined;
+            }> & Schema.Struct<{
+                readonly kind: Schema.Literals<readonly ["skill", "mcp"]>;
+                readonly refresh: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+                readonly query: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+            }>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly items: readonly {
+                    readonly registry: string;
+                    readonly kind: "mcp" | "skill";
+                    readonly id: string;
+                    readonly name: string;
+                    readonly description: string;
+                    readonly category?: string | undefined;
+                    readonly author?: string | undefined;
+                    readonly url?: string | undefined;
+                    readonly tags: readonly string[];
+                    readonly prerequisites: readonly string[];
+                    readonly parameters: readonly {
+                        readonly key: string;
+                        readonly name: string;
+                        readonly placeholder?: string | undefined;
+                        readonly optional: boolean;
+                        readonly secret?: boolean | undefined;
+                    }[];
+                    readonly options: readonly {
+                        readonly name: string;
+                        readonly description?: string | undefined;
+                        readonly prerequisites: readonly string[];
+                        readonly parameters: readonly {
+                            readonly key: string;
+                            readonly name: string;
+                            readonly placeholder?: string | undefined;
+                            readonly optional: boolean;
+                            readonly secret?: boolean | undefined;
+                        }[];
+                    }[];
+                }[];
+                readonly failures: readonly {
+                    readonly registry: string;
+                    readonly message: string;
+                }[];
+            }, {
+                readonly items: readonly {
+                    readonly registry: string;
+                    readonly kind: "mcp" | "skill";
+                    readonly id: string;
+                    readonly name: string;
+                    readonly description: string;
+                    readonly category?: string | undefined;
+                    readonly author?: string | undefined;
+                    readonly url?: string | undefined;
+                    readonly tags: readonly string[];
+                    readonly prerequisites: readonly string[];
+                    readonly parameters: readonly {
+                        readonly key: string;
+                        readonly name: string;
+                        readonly placeholder?: string | undefined;
+                        readonly optional: boolean;
+                        readonly secret?: boolean | undefined;
+                    }[];
+                    readonly options: readonly {
+                        readonly name: string;
+                        readonly description?: string | undefined;
+                        readonly prerequisites: readonly string[];
+                        readonly parameters: readonly {
+                            readonly key: string;
+                            readonly name: string;
+                            readonly placeholder?: string | undefined;
+                            readonly optional: boolean;
+                            readonly secret?: boolean | undefined;
+                        }[];
+                    }[];
+                }[];
+                readonly failures: readonly {
+                    readonly registry: string;
+                    readonly message: string;
+                }[];
+            }> & Schema.Struct<{
+                readonly items: Schema.$Array<Schema.Struct<{
+                    readonly registry: Schema.String;
+                    readonly kind: Schema.Literals<readonly ["skill", "mcp"]>;
+                    readonly id: Schema.String;
+                    readonly name: Schema.String;
+                    readonly description: Schema.String;
+                    readonly category: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                    readonly author: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                    readonly url: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                    readonly tags: Schema.$Array<Schema.String>;
+                    readonly prerequisites: Schema.$Array<Schema.String>;
+                    /** Parameters shared by every install option. */
+                    readonly parameters: Schema.$Array<Schema.Struct<{
+                        readonly key: Schema.String;
+                        readonly name: Schema.String;
+                        readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                        readonly optional: Schema.Boolean;
+                        /** Mask entry in clients; supplied values can still be stored as plaintext in MCP config. */
+                        readonly secret: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+                    }>>;
+                    readonly options: Schema.$Array<Schema.Struct<{
+                        readonly name: Schema.String;
+                        readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                        readonly prerequisites: Schema.$Array<Schema.String>;
+                        readonly parameters: Schema.$Array<Schema.Struct<{
+                            readonly key: Schema.String;
+                            readonly name: Schema.String;
+                            readonly placeholder: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                            readonly optional: Schema.Boolean;
+                            /** Mask entry in clients; supplied values can still be stored as plaintext in MCP config. */
+                            readonly secret: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+                        }>>;
+                    }>>;
+                }>>;
+                /** A failed refresh can return the persisted catalog with a warning. */
+                readonly failures: Schema.$Array<Schema.Struct<{
+                    readonly registry: Schema.String;
+                    readonly message: Schema.String;
+                }>>;
+            }>;
+            errors: {
+                fetch_failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                not_found: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                conflict: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                invalid_params: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                write_failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                unsupported: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        installed: {
+            input: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            output: import("effect/StandardSchema").StandardSchemaV1<readonly {
+                readonly version?: 1 | undefined;
+                readonly registry: string;
+                readonly kind: "mcp" | "skill";
+                readonly id: string;
+                readonly scope: "global" | "project";
+                readonly project?: string | undefined;
+                readonly config?: string | undefined;
+                readonly server?: string | undefined;
+                readonly resources?: readonly ({
+                    readonly id: string;
+                    readonly fingerprints?: readonly string[] | undefined;
+                } | {
+                    readonly server: string;
+                    readonly fingerprints?: readonly string[] | undefined;
+                })[] | undefined;
+                readonly recovering?: boolean | undefined;
+                readonly status?: "incomplete" | "missing" | "modified" | "ready" | undefined;
+                readonly warnings?: readonly string[] | undefined;
+                readonly pending?: readonly ({
+                    readonly id: string;
+                    readonly fingerprints?: readonly string[] | undefined;
+                } | {
+                    readonly server: string;
+                    readonly fingerprints?: readonly string[] | undefined;
+                })[] | undefined;
+                readonly installedAt: number;
+            }[], readonly {
+                readonly version?: 1 | undefined;
+                readonly registry: string;
+                readonly kind: "mcp" | "skill";
+                readonly id: string;
+                readonly scope: "global" | "project";
+                readonly project?: string | undefined;
+                readonly config?: string | undefined;
+                readonly server?: string | undefined;
+                readonly resources?: readonly ({
+                    readonly id: string;
+                    readonly fingerprints?: readonly string[] | undefined;
+                } | {
+                    readonly server: string;
+                    readonly fingerprints?: readonly string[] | undefined;
+                })[] | undefined;
+                readonly recovering?: boolean | undefined;
+                readonly status?: "incomplete" | "missing" | "modified" | "ready" | undefined;
+                readonly warnings?: readonly string[] | undefined;
+                readonly pending?: readonly ({
+                    readonly id: string;
+                    readonly fingerprints?: readonly string[] | undefined;
+                } | {
+                    readonly server: string;
+                    readonly fingerprints?: readonly string[] | undefined;
+                })[] | undefined;
+                readonly installedAt: number;
+            }[]> & Schema.$Array<Schema.Struct<{
+                /** Stored record format; an unknown version is skipped instead of being misread. */
+                readonly version: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literal<1>>>, Schema.optionalKey<Schema.Literal<1>>, never, never>;
+                readonly registry: Schema.String;
+                readonly kind: Schema.Literals<readonly ["skill", "mcp"]>;
+                readonly id: Schema.String;
+                readonly scope: Schema.Literals<readonly ["global", "project"]>;
+                readonly project: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                /** MCP config file relative to the scope root, so records survive moving the project. */
+                readonly config: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                /** Native mcp.servers key, used for status and sign-in handoff. */
+                readonly server: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                readonly resources: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                }>, Schema.Struct<{
+                    readonly server: Schema.String;
+                    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                }>]>>>>, Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                }>, Schema.Struct<{
+                    readonly server: Schema.String;
+                    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                }>]>>>, never, never>;
+                /** Intent persisted before mutations, recoverable by retry or uninstall. */
+                readonly recovering: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+                readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["ready", "missing", "modified", "incomplete"]>>>, Schema.optionalKey<Schema.Literals<readonly ["ready", "missing", "modified", "incomplete"]>>, never, never>;
+                readonly warnings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                /** Obsolete resources remain owned until cleanup succeeds. */
+                readonly pending: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                }>, Schema.Struct<{
+                    readonly server: Schema.String;
+                    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                }>]>>>>, Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                }>, Schema.Struct<{
+                    readonly server: Schema.String;
+                    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                }>]>>>, never, never>;
+                readonly installedAt: Schema.Number;
+            }>>;
+            errors: {
+                fetch_failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                not_found: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                conflict: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                invalid_params: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                write_failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                unsupported: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        /** Read-only preview; redact secrets before interpolating the template. */
+        preview: {
+            input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly registry: string;
+                readonly kind: "mcp" | "skill";
+                readonly id: string;
+                readonly scope: "global" | "project";
+                readonly option?: string | undefined;
+                readonly params?: {
+                    readonly [x: string]: string;
+                } | undefined;
+            }, {
+                readonly registry: string;
+                readonly kind: "mcp" | "skill";
+                readonly id: string;
+                readonly scope: "global" | "project";
+                readonly option?: string | undefined;
+                readonly params?: {
+                    readonly [x: string]: string;
+                } | undefined;
+            }> & Schema.Struct<{
+                readonly registry: Schema.String;
+                readonly kind: Schema.Literals<readonly ["skill", "mcp"]>;
+                readonly id: Schema.String;
+                readonly scope: Schema.Literals<readonly ["global", "project"]>;
+                readonly option: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                readonly params: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+            }>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly config: string;
+                readonly server: string;
+                readonly parameters: readonly string[];
+                readonly secrets: readonly string[];
+            }, {
+                readonly config: string;
+                readonly server: string;
+                readonly parameters: readonly string[];
+                readonly secrets: readonly string[];
+            }> & Schema.Struct<{
+                readonly config: Schema.String;
+                readonly server: Schema.String;
+                readonly parameters: Schema.$Array<Schema.String>;
+                /** Names of nonempty secret parameters that will be stored in plaintext. */
+                readonly secrets: Schema.$Array<Schema.String>;
+            }>;
+            errors: {
+                fetch_failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                not_found: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                conflict: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                invalid_params: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                write_failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                unsupported: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        install: {
+            input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly registry: string;
+                readonly kind: "mcp" | "skill";
+                readonly id: string;
+                readonly scope: "global" | "project";
+                readonly option?: string | undefined;
+                readonly params?: {
+                    readonly [x: string]: string;
+                } | undefined;
+            }, {
+                readonly registry: string;
+                readonly kind: "mcp" | "skill";
+                readonly id: string;
+                readonly scope: "global" | "project";
+                readonly option?: string | undefined;
+                readonly params?: {
+                    readonly [x: string]: string;
+                } | undefined;
+            }> & Schema.Struct<{
+                readonly registry: Schema.String;
+                readonly kind: Schema.Literals<readonly ["skill", "mcp"]>;
+                readonly id: Schema.String;
+                readonly scope: Schema.Literals<readonly ["global", "project"]>;
+                readonly option: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                readonly params: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.String>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>, never, never>;
+            }>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly version?: 1 | undefined;
+                readonly registry: string;
+                readonly kind: "mcp" | "skill";
+                readonly id: string;
+                readonly scope: "global" | "project";
+                readonly project?: string | undefined;
+                readonly config?: string | undefined;
+                readonly server?: string | undefined;
+                readonly resources?: readonly ({
+                    readonly id: string;
+                    readonly fingerprints?: readonly string[] | undefined;
+                } | {
+                    readonly server: string;
+                    readonly fingerprints?: readonly string[] | undefined;
+                })[] | undefined;
+                readonly recovering?: boolean | undefined;
+                readonly status?: "incomplete" | "missing" | "modified" | "ready" | undefined;
+                readonly warnings?: readonly string[] | undefined;
+                readonly pending?: readonly ({
+                    readonly id: string;
+                    readonly fingerprints?: readonly string[] | undefined;
+                } | {
+                    readonly server: string;
+                    readonly fingerprints?: readonly string[] | undefined;
+                })[] | undefined;
+                readonly installedAt: number;
+            }, {
+                readonly version?: 1 | undefined;
+                readonly registry: string;
+                readonly kind: "mcp" | "skill";
+                readonly id: string;
+                readonly scope: "global" | "project";
+                readonly project?: string | undefined;
+                readonly config?: string | undefined;
+                readonly server?: string | undefined;
+                readonly resources?: readonly ({
+                    readonly id: string;
+                    readonly fingerprints?: readonly string[] | undefined;
+                } | {
+                    readonly server: string;
+                    readonly fingerprints?: readonly string[] | undefined;
+                })[] | undefined;
+                readonly recovering?: boolean | undefined;
+                readonly status?: "incomplete" | "missing" | "modified" | "ready" | undefined;
+                readonly warnings?: readonly string[] | undefined;
+                readonly pending?: readonly ({
+                    readonly id: string;
+                    readonly fingerprints?: readonly string[] | undefined;
+                } | {
+                    readonly server: string;
+                    readonly fingerprints?: readonly string[] | undefined;
+                })[] | undefined;
+                readonly installedAt: number;
+            }> & Schema.Struct<{
+                /** Stored record format; an unknown version is skipped instead of being misread. */
+                readonly version: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literal<1>>>, Schema.optionalKey<Schema.Literal<1>>, never, never>;
+                readonly registry: Schema.String;
+                readonly kind: Schema.Literals<readonly ["skill", "mcp"]>;
+                readonly id: Schema.String;
+                readonly scope: Schema.Literals<readonly ["global", "project"]>;
+                readonly project: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                /** MCP config file relative to the scope root, so records survive moving the project. */
+                readonly config: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                /** Native mcp.servers key, used for status and sign-in handoff. */
+                readonly server: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                readonly resources: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                }>, Schema.Struct<{
+                    readonly server: Schema.String;
+                    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                }>]>>>>, Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                }>, Schema.Struct<{
+                    readonly server: Schema.String;
+                    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                }>]>>>, never, never>;
+                /** Intent persisted before mutations, recoverable by retry or uninstall. */
+                readonly recovering: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
+                readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Literals<readonly ["ready", "missing", "modified", "incomplete"]>>>, Schema.optionalKey<Schema.Literals<readonly ["ready", "missing", "modified", "incomplete"]>>, never, never>;
+                readonly warnings: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                /** Obsolete resources remain owned until cleanup succeeds. */
+                readonly pending: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                }>, Schema.Struct<{
+                    readonly server: Schema.String;
+                    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                }>]>>>>, Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                }>, Schema.Struct<{
+                    readonly server: Schema.String;
+                    readonly fingerprints: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+                }>]>>>, never, never>;
+                readonly installedAt: Schema.Number;
+            }>;
+            errors: {
+                fetch_failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                not_found: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                conflict: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                invalid_params: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                write_failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                unsupported: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+        uninstall: {
+            input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly registry: string;
+                readonly kind: "mcp" | "skill";
+                readonly id: string;
+                readonly scope: "global" | "project";
+            }, {
+                readonly registry: string;
+                readonly kind: "mcp" | "skill";
+                readonly id: string;
+                readonly scope: "global" | "project";
+            }> & Schema.Struct<{
+                readonly registry: Schema.String;
+                readonly kind: Schema.Literals<readonly ["skill", "mcp"]>;
+                readonly id: Schema.String;
+                readonly scope: Schema.Literals<readonly ["global", "project"]>;
+            }>;
+            output: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            errors: {
+                fetch_failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                not_found: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                conflict: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                invalid_params: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                write_failed: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+                unsupported: import("effect/StandardSchema").StandardSchemaV1<undefined, undefined> & Schema.Undefined;
+            };
+        };
+    };
+    readonly events: {};
+};