@codemcp/ade-core 0.0.2

package/dist/catalog/facets/practices.js

@@ -0,0 +1,163 @@
+export const practicesFacet = {
+    id: "practices",
+    label: "Practices",
+    description: "Composable development practices — mix and match regardless of stack",
+    required: false,
+    multiSelect: true,
+    options: [
+        {
+            id: "conventional-commits",
+            label: "Conventional Commits",
+            description: "Structured commit messages following the Conventional Commits specification",
+            recipe: [
+                {
+                    writer: "skills",
+                    config: {
+                        skills: [
+                            {
+                                name: "conventional-commits",
+                                description: "Conventional Commits specification for structured commit messages",
+                                body: [
+                                    "# Conventional Commits",
+                                    "",
+                                    "## Format",
+                                    "```",
+                                    "<type>[optional scope]: <description>",
+                                    "",
+                                    "[optional body]",
+                                    "",
+                                    "[optional footer(s)]",
+                                    "```",
+                                    "",
+                                    "## Types",
+                                    "- `feat`: A new feature (correlates with MINOR in SemVer)",
+                                    "- `fix`: A bug fix (correlates with PATCH in SemVer)",
+                                    "- `docs`: Documentation only changes",
+                                    "- `style`: Changes that do not affect the meaning of the code",
+                                    "- `refactor`: A code change that neither fixes a bug nor adds a feature",
+                                    "- `perf`: A code change that improves performance",
+                                    "- `test`: Adding missing tests or correcting existing tests",
+                                    "- `chore`: Changes to the build process or auxiliary tools",
+                                    "",
+                                    "## Rules",
+                                    "- Subject line must not exceed 72 characters",
+                                    '- Use imperative mood in the subject line ("add" not "added")',
+                                    "- Do not end the subject line with a period",
+                                    "- Separate subject from body with a blank line",
+                                    "- Use the body to explain what and why, not how",
+                                    "- `BREAKING CHANGE:` footer or `!` after type/scope for breaking changes"
+                                ].join("\n")
+                            }
+                        ]
+                    }
+                }
+            ],
+            docsets: [
+                {
+                    id: "conventional-commits-spec",
+                    label: "Conventional Commits Spec",
+                    origin: "https://github.com/conventional-commits/conventionalcommits.org.git",
+                    description: "The Conventional Commits specification"
+                }
+            ]
+        },
+        {
+            id: "tdd-london",
+            label: "TDD (London Style)",
+            description: "Test-Driven Development using the London school (mockist) approach",
+            recipe: [
+                {
+                    writer: "skills",
+                    config: {
+                        skills: [
+                            {
+                                name: "tdd-london",
+                                description: "London-school TDD methodology with outside-in design",
+                                body: [
+                                    "# TDD — London Style (Mockist)",
+                                    "",
+                                    "## Core Cycle",
+                                    "1. **Red** — Write a failing test for the next behavior",
+                                    "2. **Green** — Write the minimum code to make the test pass",
+                                    "3. **Refactor** — Improve the code while keeping tests green",
+                                    "",
+                                    "## London School Principles",
+                                    "- Work **outside-in**: start from the outermost layer (API / UI) and drive inward",
+                                    "- **Mock collaborators**: each unit test isolates the unit under test by mocking its direct dependencies",
+                                    "- Discover interfaces through tests — let the test define the collaborator contract before implementing it",
+                                    "- Prefer **role-based interfaces** over concrete classes",
+                                    "",
+                                    "## Test Structure",
+                                    "- **Arrange**: Set up mocks and the unit under test",
+                                    "- **Act**: Call the method being tested",
+                                    "- **Assert**: Verify the unit's output and interactions with mocks",
+                                    "",
+                                    "## Guidelines",
+                                    "- One logical assertion per test",
+                                    '- Test names describe behavior, not methods (e.g. "notifies user when order is placed")',
+                                    "- Only mock types you own — wrap third-party APIs in adapters and mock those",
+                                    "- Use the test doubles: stubs for queries, mocks for commands",
+                                    "- Do not test implementation details — test observable behavior",
+                                    "- Refactor step is mandatory, not optional"
+                                ].join("\n")
+                            }
+                        ]
+                    }
+                }
+            ]
+        },
+        {
+            id: "adr-nygard",
+            label: "ADR (Nygard)",
+            description: "Architecture Decision Records following Michael Nygard's template",
+            recipe: [
+                {
+                    writer: "skills",
+                    config: {
+                        skills: [
+                            {
+                                name: "adr-nygard",
+                                description: "Architecture Decision Records following Nygard's lightweight template",
+                                body: [
+                                    "# Architecture Decision Records (Nygard)",
+                                    "",
+                                    "## When to Write an ADR",
+                                    "- When making a significant architectural decision",
+                                    "- When choosing between multiple viable options",
+                                    "- When the decision will be hard to reverse",
+                                    '- When future developers will ask "why did we do this?"',
+                                    "",
+                                    "## Template",
+                                    "Store ADRs in `docs/adr/` as numbered markdown files: `NNNN-title-with-dashes.md`",
+                                    "",
+                                    "```markdown",
+                                    "# N. Title",
+                                    "",
+                                    "## Status",
+                                    "Proposed | Accepted | Deprecated | Superseded by [ADR-NNNN]",
+                                    "",
+                                    "## Context",
+                                    "What is the issue that we're seeing that is motivating this decision or change?",
+                                    "",
+                                    "## Decision",
+                                    "What is the change that we're proposing and/or doing?",
+                                    "",
+                                    "## Consequences",
+                                    "What becomes easier or more difficult to do because of this change?",
+                                    "```",
+                                    "",
+                                    "## Rules",
+                                    "- ADRs are immutable once accepted — supersede, don't edit",
+                                    "- Keep context focused on forces at play at the time of the decision",
+                                    "- Write consequences as both positive and negative impacts",
+                                    "- Number sequentially, never reuse numbers",
+                                    '- Title should be a short noun phrase (e.g. "Use PostgreSQL for persistence")'
+                                ].join("\n")
+                            }
+                        ]
+                    }
+                }
+            ]
+        }
+    ]
+};

package/dist/catalog/facets/process.d.ts

@@ -0,0 +1,2 @@
+import type { Facet } from "../../types.js";
+export declare const processFacet: Facet;

package/dist/catalog/facets/process.js

@@ -0,0 +1,47 @@
+export const processFacet = {
+    id: "process",
+    label: "Process",
+    description: "How your AI agent receives and executes tasks",
+    required: true,
+    options: [
+        {
+            id: "codemcp-workflows",
+            label: "CodeMCP Workflows",
+            description: "Use @codemcp/workflows to drive agent tasks with structured engineering workflows",
+            recipe: [
+                {
+                    writer: "workflows",
+                    config: {
+                        package: "@codemcp/workflows-server@latest",
+                        ref: "workflows"
+                    }
+                },
+                {
+                    writer: "instruction",
+                    config: {
+                        text: [
+                            "You are an AI assistant that helps users develop software features using the workflows server.",
+                            "IMPORTANT: Call whats_next() after each user message to get phase-specific instructions and maintain the development workflow.",
+                            'Each tool call returns a JSON response with an "instructions" field. Follow these instructions immediately after you receive them.',
+                            "Use the development plan which you will retrieve via whats_next() to record important insights and decisions as per the structure of the plan.",
+                            "Do not use your own task management tools."
+                        ].join("\n")
+                    }
+                }
+            ]
+        },
+        {
+            id: "native-agents-md",
+            label: "Native agents.md",
+            description: "Use a plain agents.md instruction file",
+            recipe: [
+                {
+                    writer: "instruction",
+                    config: {
+                        text: "Read AGENTS.md for project conventions and task instructions."
+                    }
+                }
+            ]
+        }
+    ]
+};

package/dist/catalog/index.d.ts

@@ -0,0 +1,14 @@
+import type { Catalog, Facet, Option } from "../types.js";
+export declare function getDefaultCatalog(): Catalog;
+export declare function getFacet(catalog: Catalog, id: string): Facet | undefined;
+export declare function getOption(facet: Facet, id: string): Option | undefined;
+/**
+ * Topologically sort facets so that dependency facets come before dependent ones.
+ * Uses Kahn's algorithm. Throws if a cycle is detected.
+ */
+export declare function sortFacets(catalog: Catalog): Facet[];
+/**
+ * Returns only the options of a facet that are visible given the current choices.
+ * Options without an `available()` function are always visible.
+ */
+export declare function getVisibleOptions(facet: Facet, choices: Record<string, string | string[]>, catalog: Catalog): Option[];

package/dist/catalog/index.js

@@ -0,0 +1,71 @@
+import { processFacet } from "./facets/process.js";
+import { architectureFacet } from "./facets/architecture.js";
+import { practicesFacet } from "./facets/practices.js";
+import { backpressureFacet } from "./facets/backpressure.js";
+export function getDefaultCatalog() {
+    return {
+        facets: [processFacet, architectureFacet, practicesFacet, backpressureFacet]
+    };
+}
+export function getFacet(catalog, id) {
+    return catalog.facets.find((f) => f.id === id);
+}
+export function getOption(facet, id) {
+    return facet.options.find((o) => o.id === id);
+}
+/**
+ * Topologically sort facets so that dependency facets come before dependent ones.
+ * Uses Kahn's algorithm. Throws if a cycle is detected.
+ */
+export function sortFacets(catalog) {
+    const facets = catalog.facets;
+    const idToFacet = new Map(facets.map((f) => [f.id, f]));
+    // Build in-degree and adjacency (dependsOn edge: dep → dependent)
+    const inDegree = new Map(facets.map((f) => [f.id, 0]));
+    const dependents = new Map(facets.map((f) => [f.id, []]));
+    for (const facet of facets) {
+        for (const dep of facet.dependsOn ?? []) {
+            if (idToFacet.has(dep)) {
+                inDegree.set(facet.id, (inDegree.get(facet.id) ?? 0) + 1);
+                dependents.get(dep).push(facet.id);
+            }
+        }
+    }
+    const queue = facets.filter((f) => (inDegree.get(f.id) ?? 0) === 0);
+    const result = [];
+    while (queue.length > 0) {
+        const facet = queue.shift();
+        result.push(facet);
+        for (const depId of dependents.get(facet.id) ?? []) {
+            const newDegree = (inDegree.get(depId) ?? 0) - 1;
+            inDegree.set(depId, newDegree);
+            if (newDegree === 0) {
+                queue.push(idToFacet.get(depId));
+            }
+        }
+    }
+    if (result.length !== facets.length) {
+        throw new Error("Cycle detected in facet dependsOn graph");
+    }
+    return result;
+}
+/**
+ * Returns only the options of a facet that are visible given the current choices.
+ * Options without an `available()` function are always visible.
+ */
+export function getVisibleOptions(facet, choices, catalog) {
+    return facet.options.filter((option) => {
+        if (!option.available)
+            return true;
+        const deps = {};
+        for (const depFacetId of facet.dependsOn ?? []) {
+            const depFacet = getFacet(catalog, depFacetId);
+            const choiceVal = choices[depFacetId];
+            deps[depFacetId] =
+                depFacet && typeof choiceVal === "string"
+                    ? getOption(depFacet, choiceVal)
+                    : undefined;
+        }
+        return option.available(deps);
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,5 @@
+import type { UserConfig, LockFile } from "./types.js";
+export declare function readUserConfig(dir: string): Promise<UserConfig | null>;
+export declare function writeUserConfig(dir: string, config: UserConfig): Promise<void>;
+export declare function readLockFile(dir: string): Promise<LockFile | null>;
+export declare function writeLockFile(dir: string, lock: LockFile): Promise<void>;

package/dist/config.js

@@ -0,0 +1,29 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse, stringify } from "yaml";
+const CONFIG_FILE = "config.yaml";
+const LOCK_FILE = "config.lock.yaml";
+export async function readUserConfig(dir) {
+    try {
+        const raw = await readFile(join(dir, CONFIG_FILE), "utf-8");
+        return parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeUserConfig(dir, config) {
+    await writeFile(join(dir, CONFIG_FILE), stringify(config), "utf-8");
+}
+export async function readLockFile(dir) {
+    try {
+        const raw = await readFile(join(dir, LOCK_FILE), "utf-8");
+        return parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeLockFile(dir, lock) {
+    await writeFile(join(dir, LOCK_FILE), stringify(lock), "utf-8");
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { type Catalog, type Facet, type Option, type Provision, type DocsetDef } from "./types.js";
+export { type LogicalConfig, type McpServerEntry, type CliAction, type KnowledgeSource, type SkillDefinition, type InlineSkill, type ExternalSkill, type GitHook } from "./types.js";
+export { type ResolutionContext, type ResolvedFacet } from "./types.js";
+export { type UserConfig, type LockFile } from "./types.js";
+export { type ProvisionWriter } from "./types.js";
+export { readUserConfig, writeUserConfig, readLockFile, writeLockFile } from "./config.js";
+export { type ProvisionWriterDef, type AgentWriterDef, type WriterRegistry } from "./types.js";
+export { createRegistry, registerProvisionWriter, getProvisionWriter, registerAgentWriter, getAgentWriter, createDefaultRegistry } from "./registry.js";
+export { resolve, collectDocsets } from "./resolver.js";
+export { getDefaultCatalog, getFacet, getOption, sortFacets, getVisibleOptions } from "./catalog/index.js";
+export { skillsWriter } from "./writers/skills.js";
+export { knowledgeWriter } from "./writers/knowledge.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export { readUserConfig, writeUserConfig, readLockFile, writeLockFile } from "./config.js";
+export { createRegistry, registerProvisionWriter, getProvisionWriter, registerAgentWriter, getAgentWriter, createDefaultRegistry } from "./registry.js";
+export { resolve, collectDocsets } from "./resolver.js";
+export { getDefaultCatalog, getFacet, getOption, sortFacets, getVisibleOptions } from "./catalog/index.js";
+export { skillsWriter } from "./writers/skills.js";
+export { knowledgeWriter } from "./writers/knowledge.js";

package/dist/registry.d.ts

@@ -0,0 +1,7 @@
+import type { WriterRegistry, ProvisionWriterDef, AgentWriterDef } from "./types.js";
+export declare function createRegistry(): WriterRegistry;
+export declare function registerProvisionWriter(registry: WriterRegistry, writer: ProvisionWriterDef): void;
+export declare function getProvisionWriter(registry: WriterRegistry, id: string): ProvisionWriterDef | undefined;
+export declare function registerAgentWriter(registry: WriterRegistry, agent: AgentWriterDef): void;
+export declare function getAgentWriter(registry: WriterRegistry, id: string): AgentWriterDef | undefined;
+export declare function createDefaultRegistry(): WriterRegistry;

package/dist/registry.js

@@ -0,0 +1,41 @@
+import { instructionWriter } from "./writers/instruction.js";
+import { workflowsWriter } from "./writers/workflows.js";
+import { skillsWriter } from "./writers/skills.js";
+import { knowledgeWriter } from "./writers/knowledge.js";
+import { gitHooksWriter } from "./writers/git-hooks.js";
+import { setupNoteWriter } from "./writers/setup-note.js";
+export function createRegistry() {
+    return {
+        provisions: new Map(),
+        agents: new Map()
+    };
+}
+export function registerProvisionWriter(registry, writer) {
+    registry.provisions.set(writer.id, writer);
+}
+export function getProvisionWriter(registry, id) {
+    return registry.provisions.get(id);
+}
+export function registerAgentWriter(registry, agent) {
+    registry.agents.set(agent.id, agent);
+}
+export function getAgentWriter(registry, id) {
+    return registry.agents.get(id);
+}
+export function createDefaultRegistry() {
+    const registry = createRegistry();
+    registerProvisionWriter(registry, instructionWriter);
+    registerProvisionWriter(registry, workflowsWriter);
+    registerProvisionWriter(registry, skillsWriter);
+    registerProvisionWriter(registry, knowledgeWriter);
+    registerProvisionWriter(registry, gitHooksWriter);
+    registerProvisionWriter(registry, setupNoteWriter);
+    // Stub writers for types not yet implemented
+    for (const id of ["mcp-server", "installable"]) {
+        registerProvisionWriter(registry, {
+            id,
+            write: async () => ({})
+        });
+    }
+    return registry;
+}

package/dist/resolver.d.ts

@@ -0,0 +1,7 @@
+import type { UserConfig, Catalog, WriterRegistry, LogicalConfig, DocsetDef } from "./types.js";
+export declare function resolve(userConfig: UserConfig, catalog: Catalog, registry: WriterRegistry): Promise<LogicalConfig>;
+/**
+ * Collect all unique docsets implied by the given choices.
+ * Used by the TUI to present docsets for confirmation before resolution.
+ */
+export declare function collectDocsets(choices: Record<string, string | string[]>, catalog: Catalog): DocsetDef[];

package/dist/resolver.js

@@ -0,0 +1,142 @@
+import { getFacet, getOption } from "./catalog/index.js";
+import { getProvisionWriter } from "./registry.js";
+export async function resolve(userConfig, catalog, registry) {
+    const result = {
+        mcp_servers: [],
+        instructions: [],
+        cli_actions: [],
+        knowledge_sources: [],
+        skills: [],
+        git_hooks: [],
+        setup_notes: []
+    };
+    const context = { resolved: {} };
+    for (const [facetId, optionId] of Object.entries(userConfig.choices)) {
+        const facet = getFacet(catalog, facetId);
+        if (!facet) {
+            continue;
+        }
+        const selectedIds = Array.isArray(optionId) ? optionId : [optionId];
+        for (const selectedId of selectedIds) {
+            const option = getOption(facet, selectedId);
+            if (!option) {
+                throw new Error(`Unknown option "${selectedId}" for facet "${facetId}"`);
+            }
+            context.resolved[facetId] = { optionId: selectedId, option };
+            for (const provision of option.recipe) {
+                const writer = getProvisionWriter(registry, provision.writer);
+                if (!writer) {
+                    continue;
+                }
+                const partial = await writer.write(provision.config, context);
+                if (partial.mcp_servers) {
+                    result.mcp_servers.push(...partial.mcp_servers);
+                }
+                if (partial.instructions) {
+                    result.instructions.push(...partial.instructions);
+                }
+                if (partial.cli_actions) {
+                    result.cli_actions.push(...partial.cli_actions);
+                }
+                if (partial.knowledge_sources) {
+                    result.knowledge_sources.push(...partial.knowledge_sources);
+                }
+                if (partial.skills) {
+                    result.skills.push(...partial.skills);
+                }
+                if (partial.git_hooks) {
+                    result.git_hooks.push(...partial.git_hooks);
+                }
+                if (partial.setup_notes) {
+                    result.setup_notes.push(...partial.setup_notes);
+                }
+            }
+        }
+    }
+    // Collect docsets from all selected options, dedup by id, filter exclusions
+    const seenDocsets = new Map();
+    for (const [facetId, optionId] of Object.entries(userConfig.choices)) {
+        const facet = getFacet(catalog, facetId);
+        if (!facet)
+            continue;
+        const selectedIds = Array.isArray(optionId) ? optionId : [optionId];
+        for (const selectedId of selectedIds) {
+            const option = getOption(facet, selectedId);
+            if (!option?.docsets)
+                continue;
+            for (const docset of option.docsets) {
+                if (!seenDocsets.has(docset.id)) {
+                    seenDocsets.set(docset.id, docset);
+                }
+            }
+        }
+    }
+    const excludedSet = new Set(userConfig.excluded_docsets ?? []);
+    for (const [id, docset] of seenDocsets) {
+        if (excludedSet.has(id))
+            continue;
+        result.knowledge_sources.push({
+            name: docset.id,
+            origin: docset.origin,
+            description: docset.description
+        });
+    }
+    // Add knowledge-server MCP entry if any knowledge_sources were collected
+    if (result.knowledge_sources.length > 0) {
+        result.mcp_servers.push({
+            ref: "knowledge",
+            command: "npx",
+            args: ["-y", "@codemcp/knowledge-server"],
+            env: {}
+        });
+    }
+    // Add skills-server MCP entry if any skills were collected
+    if (result.skills.length > 0) {
+        result.mcp_servers.push({
+            ref: "agentskills",
+            command: "npx",
+            args: ["-y", "@codemcp/skills-server"],
+            env: {}
+        });
+    }
+    // Merge custom section
+    if (userConfig.custom) {
+        if (userConfig.custom.instructions) {
+            result.instructions.push(...userConfig.custom.instructions);
+        }
+        if (userConfig.custom.mcp_servers) {
+            result.mcp_servers.push(...userConfig.custom.mcp_servers);
+        }
+    }
+    // Dedup mcp_servers by ref (last wins)
+    const serversByRef = new Map();
+    for (const server of result.mcp_servers) {
+        serversByRef.set(server.ref, server);
+    }
+    result.mcp_servers = Array.from(serversByRef.values());
+    return result;
+}
+/**
+ * Collect all unique docsets implied by the given choices.
+ * Used by the TUI to present docsets for confirmation before resolution.
+ */
+export function collectDocsets(choices, catalog) {
+    const seen = new Map();
+    for (const [facetId, optionId] of Object.entries(choices)) {
+        const facet = getFacet(catalog, facetId);
+        if (!facet)
+            continue;
+        const selectedIds = Array.isArray(optionId) ? optionId : [optionId];
+        for (const selectedId of selectedIds) {
+            const option = getOption(facet, selectedId);
+            if (!option?.docsets)
+                continue;
+            for (const docset of option.docsets) {
+                if (!seen.has(docset.id)) {
+                    seen.set(docset.id, docset);
+                }
+            }
+        }
+    }
+    return Array.from(seen.values());
+}

package/dist/types.d.ts

@@ -0,0 +1,110 @@
+export interface Catalog {
+    facets: Facet[];
+}
+export interface Facet {
+    id: string;
+    label: string;
+    description: string;
+    required: boolean;
+    multiSelect?: boolean;
+    dependsOn?: string[];
+    options: Option[];
+}
+export interface Option {
+    id: string;
+    label: string;
+    description: string;
+    recipe: Provision[];
+    docsets?: DocsetDef[];
+    available?: (deps: Record<string, Option | undefined>) => boolean;
+}
+export interface DocsetDef {
+    id: string;
+    label: string;
+    origin: string;
+    description: string;
+}
+export interface Provision {
+    writer: ProvisionWriter;
+    config: Record<string, unknown>;
+}
+export type ProvisionWriter = "workflows" | "skills" | "knowledge" | "mcp-server" | "instruction" | "installable" | "git-hooks" | "setup-note";
+export interface InlineSkill {
+    name: string;
+    description: string;
+    body: string;
+}
+export interface ExternalSkill {
+    name: string;
+    source: string;
+}
+export type SkillDefinition = InlineSkill | ExternalSkill;
+export interface GitHook {
+    phase: "pre-commit" | "pre-push";
+    script: string;
+}
+export interface LogicalConfig {
+    mcp_servers: McpServerEntry[];
+    instructions: string[];
+    cli_actions: CliAction[];
+    knowledge_sources: KnowledgeSource[];
+    skills: SkillDefinition[];
+    git_hooks: GitHook[];
+    setup_notes: string[];
+}
+export interface McpServerEntry {
+    ref: string;
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+    /**
+     * Tool names the agent is pre-approved to use from this server.
+     * Defaults to `["*"]` (all tools) when not specified.
+     */
+    allowedTools?: string[];
+}
+export interface CliAction {
+    command: string;
+    args: string[];
+    phase: "setup" | "install";
+}
+export interface KnowledgeSource {
+    name: string;
+    origin: string;
+    description: string;
+}
+export interface ResolutionContext {
+    resolved: Record<string, ResolvedFacet>;
+}
+export interface ResolvedFacet {
+    optionId: string;
+    option: Option;
+}
+export interface UserConfig {
+    choices: Record<string, string | string[]>;
+    excluded_docsets?: string[];
+    harnesses?: string[];
+    custom?: {
+        mcp_servers?: McpServerEntry[];
+        instructions?: string[];
+    };
+}
+export interface LockFile {
+    version: 1;
+    generated_at: string;
+    choices: Record<string, string | string[]>;
+    harnesses?: string[];
+    logical_config: LogicalConfig;
+}
+export interface ProvisionWriterDef {
+    id: string;
+    write(config: Record<string, unknown>, context: ResolutionContext): Promise<Partial<LogicalConfig>>;
+}
+export interface AgentWriterDef {
+    id: string;
+    install(config: LogicalConfig, projectRoot: string): Promise<void>;
+}
+export interface WriterRegistry {
+    provisions: Map<string, ProvisionWriterDef>;
+    agents: Map<string, AgentWriterDef>;
+}