@opengroundplan/core 0.1.1

package/dist/schema.d.ts

@@ -0,0 +1,878 @@
+/**
+ * Groundplan contracts. Every catalog entry, blueprint, adapter, and registry item
+ * validates against these. Templates are data — this file is the only place
+ * that defines what that data may look like.
+ */
+import { z } from 'zod';
+export declare const Id: z.ZodString;
+export declare const Stack: z.ZodEnum<["typescript", "python", "dotnet", "node", "go", "rust", "java", "polyglot"]>;
+export declare const Complexity: z.ZodEnum<["low", "medium", "high", "very-high"]>;
+/** Richards' architecture characteristics — the axes a recommendation scores on. */
+export declare const Characteristic: z.ZodEnum<["maintainability", "testability", "deployability", "simplicity", "scalability", "elasticity", "responsiveness", "fault-tolerance", "evolvability", "abstraction", "interoperability", "cost"]>;
+/** Conditions are evaluated against the resolved answer set, never eval'd as JS. */
+export declare const Condition: z.ZodString;
+export declare const ArchitectureEntry: z.ZodEffects<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    family: z.ZodEnum<["application", "system", "frontend", "data", "ai"]>;
+    oneLine: z.ZodString;
+    bestFor: z.ZodArray<z.ZodString, "many">;
+    avoidWhen: z.ZodArray<z.ZodString, "many">;
+    complexity: z.ZodEnum<["low", "medium", "high", "very-high"]>;
+    teamSize: z.ZodObject<{
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        min: number;
+        max: number;
+    }, {
+        min: number;
+        max: number;
+    }>;
+    /** 1–5 per characteristic; drives ranking in the decision engine. */
+    scores: z.ZodRecord<z.ZodEnum<["maintainability", "testability", "deployability", "simplicity", "scalability", "elasticity", "responsiveness", "fault-tolerance", "evolvability", "abstraction", "interoperability", "cost"]>, z.ZodNumber>;
+    stackFit: z.ZodRecord<z.ZodEnum<["typescript", "python", "dotnet", "node", "go", "rust", "java", "polyglot"]>, z.ZodEnum<["excellent", "good", "workable", "awkward", "n/a"]>>;
+    keyTradeoff: z.ZodString;
+    /** Blueprint that materializes this architecture's folder layout. */
+    overlay: z.ZodOptional<z.ZodString>;
+    /**
+     * Why this architecture ships no layout. Some are patterns you apply *inside* a layout —
+     * DDD's tactical patterns live in whatever folders the chosen architecture created — so an
+     * overlay would be an invention, not a materialisation.
+     *
+     * Exactly one of `overlay` or `guidance` is required. Neither used to be, which let an
+     * architecture ship with no layout and no reason, indistinguishable from an unfinished one.
+     */
+    guidance: z.ZodOptional<z.ZodString>;
+    sources: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    family: "application" | "system" | "frontend" | "data" | "ai";
+    oneLine: string;
+    bestFor: string[];
+    avoidWhen: string[];
+    complexity: "low" | "medium" | "high" | "very-high";
+    teamSize: {
+        min: number;
+        max: number;
+    };
+    scores: Partial<Record<"maintainability" | "testability" | "deployability" | "simplicity" | "scalability" | "elasticity" | "responsiveness" | "fault-tolerance" | "evolvability" | "abstraction" | "interoperability" | "cost", number>>;
+    stackFit: Partial<Record<"typescript" | "python" | "dotnet" | "node" | "go" | "rust" | "java" | "polyglot", "excellent" | "good" | "workable" | "awkward" | "n/a">>;
+    keyTradeoff: string;
+    sources: string[];
+    overlay?: string | undefined;
+    guidance?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    family: "application" | "system" | "frontend" | "data" | "ai";
+    oneLine: string;
+    bestFor: string[];
+    avoidWhen: string[];
+    complexity: "low" | "medium" | "high" | "very-high";
+    teamSize: {
+        min: number;
+        max: number;
+    };
+    scores: Partial<Record<"maintainability" | "testability" | "deployability" | "simplicity" | "scalability" | "elasticity" | "responsiveness" | "fault-tolerance" | "evolvability" | "abstraction" | "interoperability" | "cost", number>>;
+    stackFit: Partial<Record<"typescript" | "python" | "dotnet" | "node" | "go" | "rust" | "java" | "polyglot", "excellent" | "good" | "workable" | "awkward" | "n/a">>;
+    keyTradeoff: string;
+    sources: string[];
+    overlay?: string | undefined;
+    guidance?: string | undefined;
+}>, {
+    id: string;
+    name: string;
+    family: "application" | "system" | "frontend" | "data" | "ai";
+    oneLine: string;
+    bestFor: string[];
+    avoidWhen: string[];
+    complexity: "low" | "medium" | "high" | "very-high";
+    teamSize: {
+        min: number;
+        max: number;
+    };
+    scores: Partial<Record<"maintainability" | "testability" | "deployability" | "simplicity" | "scalability" | "elasticity" | "responsiveness" | "fault-tolerance" | "evolvability" | "abstraction" | "interoperability" | "cost", number>>;
+    stackFit: Partial<Record<"typescript" | "python" | "dotnet" | "node" | "go" | "rust" | "java" | "polyglot", "excellent" | "good" | "workable" | "awkward" | "n/a">>;
+    keyTradeoff: string;
+    sources: string[];
+    overlay?: string | undefined;
+    guidance?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    family: "application" | "system" | "frontend" | "data" | "ai";
+    oneLine: string;
+    bestFor: string[];
+    avoidWhen: string[];
+    complexity: "low" | "medium" | "high" | "very-high";
+    teamSize: {
+        min: number;
+        max: number;
+    };
+    scores: Partial<Record<"maintainability" | "testability" | "deployability" | "simplicity" | "scalability" | "elasticity" | "responsiveness" | "fault-tolerance" | "evolvability" | "abstraction" | "interoperability" | "cost", number>>;
+    stackFit: Partial<Record<"typescript" | "python" | "dotnet" | "node" | "go" | "rust" | "java" | "polyglot", "excellent" | "good" | "workable" | "awkward" | "n/a">>;
+    keyTradeoff: string;
+    sources: string[];
+    overlay?: string | undefined;
+    guidance?: string | undefined;
+}>;
+export declare const Variable: z.ZodObject<{
+    name: z.ZodString;
+    prompt: z.ZodString;
+    type: z.ZodEnum<["string", "boolean", "number", "select", "multiselect"]>;
+    choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        label: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        label: string;
+    }, {
+        value: string;
+        label: string;
+    }>, "many">>;
+    default: z.ZodOptional<z.ZodUnknown>;
+    required: z.ZodDefault<z.ZodBoolean>;
+    /** Only ask when this holds — keeps the interview short. */
+    when: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "string" | "number" | "boolean" | "select" | "multiselect";
+    prompt: string;
+    required: boolean;
+    choices?: {
+        value: string;
+        label: string;
+    }[] | undefined;
+    default?: unknown;
+    when?: string | undefined;
+}, {
+    name: string;
+    type: "string" | "number" | "boolean" | "select" | "multiselect";
+    prompt: string;
+    choices?: {
+        value: string;
+        label: string;
+    }[] | undefined;
+    default?: unknown;
+    required?: boolean | undefined;
+    when?: string | undefined;
+}>;
+/**
+ * `merge` folds a fragment into a file another blueprint owns. The format is inferred from
+ * the destination — JSON, TOML, MSBuild XML, or go.mod — so a declared strategy cannot
+ * disagree with the file it targets. `merge-json` is the original name, kept working.
+ */
+export declare const MergeStrategy: z.ZodEnum<["skip", "overwrite", "merge", "merge-json", "append", "fail"]>;
+export declare const FileRule: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodDefault<z.ZodString>;
+    when: z.ZodOptional<z.ZodString>;
+    /** Copy verbatim — for binaries and files whose syntax collides with the tokens. */
+    raw: z.ZodDefault<z.ZodBoolean>;
+    onConflict: z.ZodDefault<z.ZodEnum<["skip", "overwrite", "merge", "merge-json", "append", "fail"]>>;
+}, "strip", z.ZodTypeAny, {
+    from: string;
+    to: string;
+    raw: boolean;
+    onConflict: "skip" | "overwrite" | "merge" | "merge-json" | "append" | "fail";
+    when?: string | undefined;
+}, {
+    from: string;
+    when?: string | undefined;
+    to?: string | undefined;
+    raw?: boolean | undefined;
+    onConflict?: "skip" | "overwrite" | "merge" | "merge-json" | "append" | "fail" | undefined;
+}>;
+/**
+ * Licenses we may copy and adapt code from. Permissive only — anything copyleft would
+ * propagate its terms into every repository Groundplan generates, including commercial ones.
+ * An unlicensed repo is "all rights reserved", not "free"; it is not on this list.
+ */
+export declare const VENDORABLE_LICENSES: readonly ["MIT", "Apache-2.0", "BSD-2-Clause", "BSD-3-Clause", "ISC", "Unlicense", "0BSD", "CC0-1.0"];
+/** Apache-2.0 and BSD require the copyright notice to travel with the code. */
+export declare const ATTRIBUTION_REQUIRED: readonly ["Apache-2.0", "BSD-2-Clause", "BSD-3-Clause"];
+/**
+ * A post-apply command, which `apply` runs through a shell so steps can chain with `&&`.
+ *
+ * Tokens are rejected rather than rendered. Rendering one would put a user-supplied value —
+ * a solution name is free text — inside a shell string, so `x; rm -rf ~` would execute. That
+ * makes "postApply is never rendered" a security boundary, and this refusal is what enforces
+ * it: a contributor who adds a token here gets a catalog error, not a shell injection.
+ * Anything needing a variable belongs in a template file, which is rendered safely.
+ */
+export declare const ShellStep: z.ZodEffects<z.ZodString, string, string>;
+export declare const SourceAttribution: z.ZodObject<{
+    name: z.ZodString;
+    url: z.ZodString;
+    license: z.ZodEnum<["MIT", "Apache-2.0", "BSD-2-Clause", "BSD-3-Clause", "ISC", "Unlicense", "0BSD", "CC0-1.0"]>;
+    /** What was actually taken. "Inspired by" needs no attribution; copied code does. */
+    adapted: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    url: string;
+    license: "MIT" | "Apache-2.0" | "BSD-2-Clause" | "BSD-3-Clause" | "ISC" | "Unlicense" | "0BSD" | "CC0-1.0";
+    adapted: string;
+}, {
+    name: string;
+    url: string;
+    license: "MIT" | "Apache-2.0" | "BSD-2-Clause" | "BSD-3-Clause" | "ISC" | "Unlicense" | "0BSD" | "CC0-1.0";
+    adapted: string;
+}>;
+export declare const Blueprint: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<["base", "layer", "architecture", "agent-kit"]>;
+    name: z.ZodString;
+    description: z.ZodString;
+    /** Upstream code this blueprint adapts. Drives NOTICE generation in the output repo. */
+    sources: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodString;
+        license: z.ZodEnum<["MIT", "Apache-2.0", "BSD-2-Clause", "BSD-3-Clause", "ISC", "Unlicense", "0BSD", "CC0-1.0"]>;
+        /** What was actually taken. "Inspired by" needs no attribution; copied code does. */
+        adapted: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        url: string;
+        license: "MIT" | "Apache-2.0" | "BSD-2-Clause" | "BSD-3-Clause" | "ISC" | "Unlicense" | "0BSD" | "CC0-1.0";
+        adapted: string;
+    }, {
+        name: string;
+        url: string;
+        license: "MIT" | "Apache-2.0" | "BSD-2-Clause" | "BSD-3-Clause" | "ISC" | "Unlicense" | "0BSD" | "CC0-1.0";
+        adapted: string;
+    }>, "many">>;
+    /**
+     * What this stack's toolchain is actually invoked with. Declared by bases and read by the
+     * agent-kit, so AGENTS.md carries real commands instead of asking the user to retype what
+     * the template already knows.
+     */
+    commands: z.ZodOptional<z.ZodObject<{
+        build: z.ZodString;
+        test: z.ZodString;
+        lint: z.ZodString;
+        typecheck: z.ZodOptional<z.ZodString>;
+        dev: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        build: string;
+        test: string;
+        lint: string;
+        typecheck?: string | undefined;
+        dev?: string | undefined;
+    }, {
+        build: string;
+        test: string;
+        lint: string;
+        typecheck?: string | undefined;
+        dev?: string | undefined;
+    }>>;
+    stack: z.ZodOptional<z.ZodEnum<["typescript", "python", "dotnet", "node", "go", "rust", "java", "polyglot"]>>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Dependency algebra — resolved at plan time so broken combos never reach disk. */
+    requires: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    conflicts: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    provides: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    supportsArchitectures: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * Mutually exclusive alternatives, declared once instead of as pairwise conflicts.
+     * Six databases need fifteen conflict pairs kept in sync; they need one choiceSet.
+     * The CLI renders a set as pick-one rather than as checkboxes.
+     */
+    choiceSet: z.ZodOptional<z.ZodString>;
+    /** Bases whose framework packages this layer may import without declaring them itself. */
+    peerProvidedBy: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Preselected option when the user does not choose within this set. */
+    choiceDefault: z.ZodDefault<z.ZodBoolean>;
+    variables: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        prompt: z.ZodString;
+        type: z.ZodEnum<["string", "boolean", "number", "select", "multiselect"]>;
+        choices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            value: z.ZodString;
+            label: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            label: string;
+        }, {
+            value: string;
+            label: string;
+        }>, "many">>;
+        default: z.ZodOptional<z.ZodUnknown>;
+        required: z.ZodDefault<z.ZodBoolean>;
+        /** Only ask when this holds — keeps the interview short. */
+        when: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: "string" | "number" | "boolean" | "select" | "multiselect";
+        prompt: string;
+        required: boolean;
+        choices?: {
+            value: string;
+            label: string;
+        }[] | undefined;
+        default?: unknown;
+        when?: string | undefined;
+    }, {
+        name: string;
+        type: "string" | "number" | "boolean" | "select" | "multiselect";
+        prompt: string;
+        choices?: {
+            value: string;
+            label: string;
+        }[] | undefined;
+        default?: unknown;
+        required?: boolean | undefined;
+        when?: string | undefined;
+    }>, "many">>;
+    files: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodDefault<z.ZodString>;
+        when: z.ZodOptional<z.ZodString>;
+        /** Copy verbatim — for binaries and files whose syntax collides with the tokens. */
+        raw: z.ZodDefault<z.ZodBoolean>;
+        onConflict: z.ZodDefault<z.ZodEnum<["skip", "overwrite", "merge", "merge-json", "append", "fail"]>>;
+    }, "strip", z.ZodTypeAny, {
+        from: string;
+        to: string;
+        raw: boolean;
+        onConflict: "skip" | "overwrite" | "merge" | "merge-json" | "append" | "fail";
+        when?: string | undefined;
+    }, {
+        from: string;
+        when?: string | undefined;
+        to?: string | undefined;
+        raw?: boolean | undefined;
+        onConflict?: "skip" | "overwrite" | "merge" | "merge-json" | "append" | "fail" | undefined;
+    }>, "many">>;
+    /** Shell steps run after apply; each declares why it is safe to run unattended. */
+    postApply: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        run: z.ZodEffects<z.ZodString, string, string>;
+        when: z.ZodOptional<z.ZodString>;
+        optional: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        run: string;
+        optional: boolean;
+        when?: string | undefined;
+    }, {
+        run: string;
+        when?: string | undefined;
+        optional?: boolean | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    sources: {
+        name: string;
+        url: string;
+        license: "MIT" | "Apache-2.0" | "BSD-2-Clause" | "BSD-3-Clause" | "ISC" | "Unlicense" | "0BSD" | "CC0-1.0";
+        adapted: string;
+    }[];
+    kind: "base" | "layer" | "architecture" | "agent-kit";
+    description: string;
+    tags: string[];
+    requires: string[];
+    conflicts: string[];
+    provides: string[];
+    supportsArchitectures: string[];
+    peerProvidedBy: string[];
+    choiceDefault: boolean;
+    variables: {
+        name: string;
+        type: "string" | "number" | "boolean" | "select" | "multiselect";
+        prompt: string;
+        required: boolean;
+        choices?: {
+            value: string;
+            label: string;
+        }[] | undefined;
+        default?: unknown;
+        when?: string | undefined;
+    }[];
+    files: {
+        from: string;
+        to: string;
+        raw: boolean;
+        onConflict: "skip" | "overwrite" | "merge" | "merge-json" | "append" | "fail";
+        when?: string | undefined;
+    }[];
+    postApply: {
+        run: string;
+        optional: boolean;
+        when?: string | undefined;
+    }[];
+    commands?: {
+        build: string;
+        test: string;
+        lint: string;
+        typecheck?: string | undefined;
+        dev?: string | undefined;
+    } | undefined;
+    stack?: "typescript" | "python" | "dotnet" | "node" | "go" | "rust" | "java" | "polyglot" | undefined;
+    choiceSet?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    kind: "base" | "layer" | "architecture" | "agent-kit";
+    description: string;
+    sources?: {
+        name: string;
+        url: string;
+        license: "MIT" | "Apache-2.0" | "BSD-2-Clause" | "BSD-3-Clause" | "ISC" | "Unlicense" | "0BSD" | "CC0-1.0";
+        adapted: string;
+    }[] | undefined;
+    commands?: {
+        build: string;
+        test: string;
+        lint: string;
+        typecheck?: string | undefined;
+        dev?: string | undefined;
+    } | undefined;
+    stack?: "typescript" | "python" | "dotnet" | "node" | "go" | "rust" | "java" | "polyglot" | undefined;
+    tags?: string[] | undefined;
+    requires?: string[] | undefined;
+    conflicts?: string[] | undefined;
+    provides?: string[] | undefined;
+    supportsArchitectures?: string[] | undefined;
+    choiceSet?: string | undefined;
+    peerProvidedBy?: string[] | undefined;
+    choiceDefault?: boolean | undefined;
+    variables?: {
+        name: string;
+        type: "string" | "number" | "boolean" | "select" | "multiselect";
+        prompt: string;
+        choices?: {
+            value: string;
+            label: string;
+        }[] | undefined;
+        default?: unknown;
+        required?: boolean | undefined;
+        when?: string | undefined;
+    }[] | undefined;
+    files?: {
+        from: string;
+        when?: string | undefined;
+        to?: string | undefined;
+        raw?: boolean | undefined;
+        onConflict?: "skip" | "overwrite" | "merge" | "merge-json" | "append" | "fail" | undefined;
+    }[] | undefined;
+    postApply?: {
+        run: string;
+        when?: string | undefined;
+        optional?: boolean | undefined;
+    }[] | undefined;
+}>;
+export declare const AdapterCapability: z.ZodEnum<["instructions", "nested-instructions", "glob-scoped-rules", "slash-commands", "subagents", "hooks", "skills", "mcp"]>;
+/**
+ * How to run a tool headlessly, so delegation is an executed command rather than a routing
+ * table nobody acts on. Flags must be verified from the vendor's own docs — an
+ * approximately-right flag produces a delegation that silently does nothing.
+ */
+export declare const Invocation: z.ZodObject<{
+    binary: z.ZodString;
+    /** `{prompt}` and `{model}` are substituted at dispatch; everything else is literal. */
+    args: z.ZodArray<z.ZodString, "many">;
+    promptVia: z.ZodDefault<z.ZodEnum<["arg", "stdin"]>>;
+    /**
+     * Args appended when the caller opts into unattended file edits. Every one of these means
+     * "edit files without asking". An empty array is a valid, meaningful answer — Amp never
+     * asks, so inventing a flag for it would misdescribe the tool.
+     */
+    autoApprove: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    modelFlag: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Liveness probe, run with a short cap. */
+    detect: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Printed when no preferred tool is installed, so the failure is actionable (ADR 0007 §6). */
+    install: z.ZodString;
+    /**
+     * When these flags were last checked against the vendor's own documentation. Required, so
+     * "verified" is a date rather than a claim: a URL alone says someone looked once, and gives
+     * no way to tell whether that was last week or two years ago. `doctor` reports entries older
+     * than the window in config.
+     */
+    verifiedOn: z.ZodString;
+    /** Vendor documentation for these exact flags. The field that rots fastest (ADR 0007 §4). */
+    verified: z.ZodString;
+    /**
+     * Set when the vendor has announced end of support. The adapter stays — removing it breaks
+     * working setups — and the note explains the scope (ADR 0007 §9).
+     */
+    deprecated: z.ZodOptional<z.ZodObject<{
+        since: z.ZodString;
+        note: z.ZodString;
+        successor: z.ZodOptional<z.ZodString>;
+        source: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        since: string;
+        note: string;
+        source: string;
+        successor?: string | undefined;
+    }, {
+        since: string;
+        note: string;
+        source: string;
+        successor?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    binary: string;
+    args: string[];
+    promptVia: "arg" | "stdin";
+    autoApprove: string[];
+    modelFlag: string[];
+    detect: string[];
+    install: string;
+    verifiedOn: string;
+    verified: string;
+    deprecated?: {
+        since: string;
+        note: string;
+        source: string;
+        successor?: string | undefined;
+    } | undefined;
+}, {
+    binary: string;
+    args: string[];
+    install: string;
+    verifiedOn: string;
+    verified: string;
+    promptVia?: "arg" | "stdin" | undefined;
+    autoApprove?: string[] | undefined;
+    modelFlag?: string[] | undefined;
+    detect?: string[] | undefined;
+    deprecated?: {
+        since: string;
+        note: string;
+        source: string;
+        successor?: string | undefined;
+    } | undefined;
+}>;
+export declare const Adapter: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    /** Present only for tools with a verified headless mode; absent means "cannot delegate to". */
+    invoke: z.ZodOptional<z.ZodObject<{
+        binary: z.ZodString;
+        /** `{prompt}` and `{model}` are substituted at dispatch; everything else is literal. */
+        args: z.ZodArray<z.ZodString, "many">;
+        promptVia: z.ZodDefault<z.ZodEnum<["arg", "stdin"]>>;
+        /**
+         * Args appended when the caller opts into unattended file edits. Every one of these means
+         * "edit files without asking". An empty array is a valid, meaningful answer — Amp never
+         * asks, so inventing a flag for it would misdescribe the tool.
+         */
+        autoApprove: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        modelFlag: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Liveness probe, run with a short cap. */
+        detect: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        /** Printed when no preferred tool is installed, so the failure is actionable (ADR 0007 §6). */
+        install: z.ZodString;
+        /**
+         * When these flags were last checked against the vendor's own documentation. Required, so
+         * "verified" is a date rather than a claim: a URL alone says someone looked once, and gives
+         * no way to tell whether that was last week or two years ago. `doctor` reports entries older
+         * than the window in config.
+         */
+        verifiedOn: z.ZodString;
+        /** Vendor documentation for these exact flags. The field that rots fastest (ADR 0007 §4). */
+        verified: z.ZodString;
+        /**
+         * Set when the vendor has announced end of support. The adapter stays — removing it breaks
+         * working setups — and the note explains the scope (ADR 0007 §9).
+         */
+        deprecated: z.ZodOptional<z.ZodObject<{
+            since: z.ZodString;
+            note: z.ZodString;
+            successor: z.ZodOptional<z.ZodString>;
+            source: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            since: string;
+            note: string;
+            source: string;
+            successor?: string | undefined;
+        }, {
+            since: string;
+            note: string;
+            source: string;
+            successor?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        binary: string;
+        args: string[];
+        promptVia: "arg" | "stdin";
+        autoApprove: string[];
+        modelFlag: string[];
+        detect: string[];
+        install: string;
+        verifiedOn: string;
+        verified: string;
+        deprecated?: {
+            since: string;
+            note: string;
+            source: string;
+            successor?: string | undefined;
+        } | undefined;
+    }, {
+        binary: string;
+        args: string[];
+        install: string;
+        verifiedOn: string;
+        verified: string;
+        promptVia?: "arg" | "stdin" | undefined;
+        autoApprove?: string[] | undefined;
+        modelFlag?: string[] | undefined;
+        detect?: string[] | undefined;
+        deprecated?: {
+            since: string;
+            note: string;
+            source: string;
+            successor?: string | undefined;
+        } | undefined;
+    }>>;
+    /** True when the tool reads AGENTS.md natively — no wrapper file needed. */
+    readsAgentsMd: z.ZodBoolean;
+    capabilities: z.ZodDefault<z.ZodArray<z.ZodEnum<["instructions", "nested-instructions", "glob-scoped-rules", "slash-commands", "subagents", "hooks", "skills", "mcp"]>, "many">>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        kind: z.ZodEnum<["instructions", "rule", "command", "agent", "hook", "skill", "settings"]>;
+        /** Wrappers import AGENTS.md; only `delta` content may be inlined. */
+        mode: z.ZodDefault<z.ZodEnum<["wrapper", "delta", "settings"]>>;
+        /**
+         * Template filename under the adapter's `templates/`, when it is not the output's own
+         * basename plus `.tmpl`. A per-item output has no single basename — one template
+         * renders many files — and tools disagree on what to call it: GitHub Copilot's rule
+         * template is `instructions.md`, Windsurf's command template is `workflow.md`.
+         * Naming it here is data; inferring it was a guess that silently emitted nothing.
+         */
+        template: z.ZodOptional<z.ZodString>;
+        when: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        kind: "instructions" | "rule" | "command" | "agent" | "hook" | "skill" | "settings";
+        mode: "settings" | "wrapper" | "delta";
+        when?: string | undefined;
+        template?: string | undefined;
+    }, {
+        path: string;
+        kind: "instructions" | "rule" | "command" | "agent" | "hook" | "skill" | "settings";
+        when?: string | undefined;
+        mode?: "settings" | "wrapper" | "delta" | undefined;
+        template?: string | undefined;
+    }>, "many">>;
+    docs: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    readsAgentsMd: boolean;
+    capabilities: ("instructions" | "nested-instructions" | "glob-scoped-rules" | "slash-commands" | "subagents" | "hooks" | "skills" | "mcp")[];
+    outputs: {
+        path: string;
+        kind: "instructions" | "rule" | "command" | "agent" | "hook" | "skill" | "settings";
+        mode: "settings" | "wrapper" | "delta";
+        when?: string | undefined;
+        template?: string | undefined;
+    }[];
+    invoke?: {
+        binary: string;
+        args: string[];
+        promptVia: "arg" | "stdin";
+        autoApprove: string[];
+        modelFlag: string[];
+        detect: string[];
+        install: string;
+        verifiedOn: string;
+        verified: string;
+        deprecated?: {
+            since: string;
+            note: string;
+            source: string;
+            successor?: string | undefined;
+        } | undefined;
+    } | undefined;
+    docs?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    readsAgentsMd: boolean;
+    invoke?: {
+        binary: string;
+        args: string[];
+        install: string;
+        verifiedOn: string;
+        verified: string;
+        promptVia?: "arg" | "stdin" | undefined;
+        autoApprove?: string[] | undefined;
+        modelFlag?: string[] | undefined;
+        detect?: string[] | undefined;
+        deprecated?: {
+            since: string;
+            note: string;
+            source: string;
+            successor?: string | undefined;
+        } | undefined;
+    } | undefined;
+    capabilities?: ("instructions" | "nested-instructions" | "glob-scoped-rules" | "slash-commands" | "subagents" | "hooks" | "skills" | "mcp")[] | undefined;
+    outputs?: {
+        path: string;
+        kind: "instructions" | "rule" | "command" | "agent" | "hook" | "skill" | "settings";
+        when?: string | undefined;
+        mode?: "settings" | "wrapper" | "delta" | undefined;
+        template?: string | undefined;
+    }[] | undefined;
+    docs?: string | undefined;
+}>;
+/**
+ * Not every registry item is delivered by an AI tool. A secret-scanning git hook works
+ * regardless of which agent is driving, and a convention stated in AGENTS.md reaches every
+ * tool at once. Modelling these as adapters would be a lie; they get their own targets.
+ */
+export declare const UNIVERSAL_TARGETS: readonly ["agents-md", "git-hooks"];
+export declare const UniversalTarget: z.ZodEnum<["agents-md", "git-hooks"]>;
+export declare const RegistryItem: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<["skill", "command", "hook", "agent"]>;
+    name: z.ZodString;
+    description: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Adapter ids or universal targets. Tools skip what they cannot express. */
+    targets: z.ZodArray<z.ZodString, "many">;
+    requiresCapability: z.ZodDefault<z.ZodArray<z.ZodEnum<["instructions", "nested-instructions", "glob-scoped-rules", "slash-commands", "subagents", "hooks", "skills", "mcp"]>, "many">>;
+    when: z.ZodOptional<z.ZodString>;
+    /**
+     * The item's markdown, read from the sibling file by the loader rather than authored here.
+     * Adapters render it into their tool's own shape; an item with no body would emit an empty
+     * rule file, so the loader refuses one.
+     */
+    body: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    kind: "command" | "agent" | "hook" | "skill";
+    description: string;
+    tags: string[];
+    targets: string[];
+    requiresCapability: ("instructions" | "nested-instructions" | "glob-scoped-rules" | "slash-commands" | "subagents" | "hooks" | "skills" | "mcp")[];
+    body: string;
+    when?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    kind: "command" | "agent" | "hook" | "skill";
+    description: string;
+    targets: string[];
+    when?: string | undefined;
+    tags?: string[] | undefined;
+    requiresCapability?: ("instructions" | "nested-instructions" | "glob-scoped-rules" | "slash-commands" | "subagents" | "hooks" | "skills" | "mcp")[] | undefined;
+    body?: string | undefined;
+}>;
+export declare const PlannedFile: z.ZodObject<{
+    path: z.ZodString;
+    source: z.ZodString;
+    action: z.ZodEnum<["create", "overwrite", "merge", "skip"]>;
+    bytes: z.ZodNumber;
+    fromBlueprint: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    source: string;
+    action: "skip" | "overwrite" | "merge" | "create";
+    bytes: number;
+    fromBlueprint: string;
+}, {
+    path: string;
+    source: string;
+    action: "skip" | "overwrite" | "merge" | "create";
+    bytes: number;
+    fromBlueprint: string;
+}>;
+export declare const Plan: z.ZodObject<{
+    solution: z.ZodString;
+    target: z.ZodString;
+    architecture: z.ZodOptional<z.ZodString>;
+    blueprints: z.ZodArray<z.ZodString, "many">;
+    adapters: z.ZodArray<z.ZodString, "many">;
+    variables: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        source: z.ZodString;
+        action: z.ZodEnum<["create", "overwrite", "merge", "skip"]>;
+        bytes: z.ZodNumber;
+        fromBlueprint: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        source: string;
+        action: "skip" | "overwrite" | "merge" | "create";
+        bytes: number;
+        fromBlueprint: string;
+    }, {
+        path: string;
+        source: string;
+        action: "skip" | "overwrite" | "merge" | "create";
+        bytes: number;
+        fromBlueprint: string;
+    }>, "many">;
+    /** `optional` steps may fail without failing generation; required ones may not. */
+    postApply: z.ZodArray<z.ZodObject<{
+        run: z.ZodEffects<z.ZodString, string, string>;
+        optional: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        run: string;
+        optional: boolean;
+    }, {
+        run: string;
+        optional?: boolean | undefined;
+    }>, "many">;
+    warnings: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /** Rendered NOTICE content when any blueprint adapts upstream code; absent otherwise. */
+    notice: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    variables: Record<string, unknown>;
+    files: {
+        path: string;
+        source: string;
+        action: "skip" | "overwrite" | "merge" | "create";
+        bytes: number;
+        fromBlueprint: string;
+    }[];
+    postApply: {
+        run: string;
+        optional: boolean;
+    }[];
+    solution: string;
+    target: string;
+    blueprints: string[];
+    adapters: string[];
+    warnings: string[];
+    architecture?: string | undefined;
+    notice?: string | undefined;
+}, {
+    variables: Record<string, unknown>;
+    files: {
+        path: string;
+        source: string;
+        action: "skip" | "overwrite" | "merge" | "create";
+        bytes: number;
+        fromBlueprint: string;
+    }[];
+    postApply: {
+        run: string;
+        optional?: boolean | undefined;
+    }[];
+    solution: string;
+    target: string;
+    blueprints: string[];
+    adapters: string[];
+    architecture?: string | undefined;
+    warnings?: string[] | undefined;
+    notice?: string | undefined;
+}>;
+export type Stack = z.infer<typeof Stack>;
+export type Characteristic = z.infer<typeof Characteristic>;
+export type ArchitectureEntry = z.infer<typeof ArchitectureEntry>;
+export type Variable = z.infer<typeof Variable>;
+export type FileRule = z.infer<typeof FileRule>;
+export type SourceAttribution = z.infer<typeof SourceAttribution>;
+export type Blueprint = z.infer<typeof Blueprint>;
+export type Adapter = z.infer<typeof Adapter>;
+export type AdapterCapability = z.infer<typeof AdapterCapability>;
+export type RegistryItem = z.infer<typeof RegistryItem>;
+export type PlannedFile = z.infer<typeof PlannedFile>;
+export type Plan = z.infer<typeof Plan>;