@microck/canonfig 2.0.0 → 2.1.0

package/dist/harness-configuration/adapters/hermes.js

@@ -0,0 +1,105 @@
+import { descriptor } from "./descriptor.js";
+import { enabledHooks, readCanonfigText } from "./shared.js";
+function projectContext(context, root) {
+    const rules = context.config.instructions.rules.length === 0
+        ? ["- No additional scoped rules are configured."]
+        : context.config.instructions.rules.map((rule) => {
+            const scope = rule.paths.length ? rule.paths.join(", ") : "all files";
+            return `- ${scope}: read \`.canonfig/${rule.file}\`.`;
+        });
+    const agents = context.config.agents.length === 0
+        ? ["- No canonical agent profiles are configured."]
+        : context.config.agents.map((agent) => `- ${agent.id}: ${agent.description} (source: \`.canonfig/${agent.file}\`).`);
+    const commands = context.config.commands.length === 0
+        ? ["- No canonical commands are configured."]
+        : context.config.commands.map((command) => `- ${command.id}: ${command.description} (source: \`.canonfig/${command.file}\`).`);
+    const skills = context.config.skills.roots.length === 0
+        ? ["- No canonical skill roots are configured."]
+        : context.config.skills.roots.map((skillRoot) => `- Inspect \`.canonfig/${skillRoot}\` or the projected \`.agents/skills\` directory for relevant SKILL.md packages.`);
+    return [
+        "# Canonfig project context for Hermes",
+        "",
+        root.trim(),
+        "",
+        "## Scoped rules",
+        "",
+        ...rules,
+        "",
+        "## Canonical skills",
+        "",
+        ...skills,
+        "",
+        "Hermes does not discover project-local skills as native profile skills. Read the relevant SKILL.md package before applying a documented workflow.",
+        "",
+        "## Canonical agent profiles",
+        "",
+        ...agents,
+        "",
+        "Treat an explicitly requested profile as task-specific instructions; Hermes does not install these as native profile agents.",
+        "",
+        "## Canonical commands",
+        "",
+        ...commands,
+        "",
+        "When the user invokes one of these command names, read its source and execute that workflow.",
+    ].join("\n");
+}
+export const hermesAdapter = {
+    descriptor: descriptor("hermes", "Hermes Agent", ["hermes"], [
+        "https://github.com/NousResearch/hermes-agent/blob/main/website/docs/user-guide/features/context-files.md",
+        "https://github.com/NousResearch/hermes-agent/blob/main/website/docs/user-guide/features/skills.md",
+        "https://github.com/NousResearch/hermes-agent/blob/main/website/docs/user-guide/features/mcp.md",
+        "https://github.com/NousResearch/hermes-agent/blob/main/website/docs/user-guide/features/hooks.md",
+    ], {
+        instructions: "native",
+        rules: "translated",
+        skills: "translated",
+        mcp: "lossy",
+        hooks: "lossy",
+        agents: "translated",
+        commands: "translated",
+        permissions: "lossy",
+    }, [
+        "Hermes natively loads project AGENTS.md and .hermes.md context, including nested AGENTS.md discovery.",
+        "Hermes skills, MCP servers, hooks, and permanent permissions are stored under the active HERMES_HOME profile, outside Canonfig's repository-confined writer.",
+        "The adapter projects skills, agents, and commands into .hermes.md as explicit source references rather than mutating profile-scoped state.",
+    ], "2026-08-26"),
+    async build(context) {
+        const diagnostics = [];
+        const root = await readCanonfigText(context, context.config.instructions.root);
+        const artifacts = [{
+                kind: "managed-text",
+                path: ".hermes.md",
+                owner: "hermes",
+                marker: "project-context",
+                comments: "html",
+                placement: "end",
+                content: projectContext(context, root),
+            }];
+        if (Object.keys(context.config.mcp.servers).length > 0) {
+            diagnostics.push({
+                level: "warning",
+                code: "HERMES_PROFILE_MCP_REQUIRED",
+                target: "hermes",
+                message: "Hermes MCP servers live in the active profile's config.yaml; Canonfig left them uninstalled rather than writing outside the repository.",
+            });
+        }
+        if (enabledHooks(context).length > 0) {
+            diagnostics.push({
+                level: "warning",
+                code: "HERMES_PROFILE_HOOKS_REQUIRED",
+                target: "hermes",
+                message: "Hermes shell hooks live in the active profile's config.yaml; Canonfig left them uninstalled rather than writing outside the repository.",
+            });
+        }
+        if (context.config.permissions.rules.length > 0) {
+            diagnostics.push({
+                level: "warning",
+                code: "HERMES_PROFILE_PERMISSIONS_REQUIRED",
+                target: "hermes",
+                message: "Hermes permission state is profile-scoped; canonical project permission rules were not installed automatically.",
+            });
+        }
+        return { artifacts, diagnostics };
+    },
+};

package/dist/harness-configuration/adapters/index.js

@@ -0,0 +1,50 @@
+export { codexAdapter } from "./codex.js";
+export { claudeAdapter } from "./claude.js";
+export { ampAdapter } from "./amp.js";
+export { ompAdapter } from "./omp.js";
+export { piAdapter } from "./pi.js";
+export { droidAdapter } from "./droid.js";
+export { cursorAdapter } from "./cursor.js";
+export { devinAdapter } from "./devin.js";
+export { opencodeAdapter } from "./opencode.js";
+export { grokAdapter } from "./grok.js";
+export { antigravityAdapter } from "./antigravity.js";
+export { copilotAdapter } from "./copilot.js";
+export { kimiAdapter } from "./kimi.js";
+export { kiloAdapter } from "./kilo.js";
+export { hermesAdapter } from "./hermes.js";
+export { qwenAdapter } from "./qwen.js";
+import { codexAdapter } from "./codex.js";
+import { claudeAdapter } from "./claude.js";
+import { ampAdapter } from "./amp.js";
+import { ompAdapter } from "./omp.js";
+import { piAdapter } from "./pi.js";
+import { droidAdapter } from "./droid.js";
+import { cursorAdapter } from "./cursor.js";
+import { devinAdapter } from "./devin.js";
+import { opencodeAdapter } from "./opencode.js";
+import { grokAdapter } from "./grok.js";
+import { antigravityAdapter } from "./antigravity.js";
+import { copilotAdapter } from "./copilot.js";
+import { kimiAdapter } from "./kimi.js";
+import { kiloAdapter } from "./kilo.js";
+import { hermesAdapter } from "./hermes.js";
+import { qwenAdapter } from "./qwen.js";
+export const BUILTIN_ADAPTERS = [
+    codexAdapter,
+    claudeAdapter,
+    ampAdapter,
+    ompAdapter,
+    piAdapter,
+    droidAdapter,
+    cursorAdapter,
+    devinAdapter,
+    opencodeAdapter,
+    grokAdapter,
+    antigravityAdapter,
+    copilotAdapter,
+    kimiAdapter,
+    kiloAdapter,
+    hermesAdapter,
+    qwenAdapter,
+];

package/dist/harness-configuration/adapters/kilo.js

@@ -0,0 +1,18 @@
+import { createOpenCodeFamilyAdapter } from "./open-code-family.js";
+export const kiloAdapter = createOpenCodeFamilyAdapter({
+    id: "kilo",
+    name: "Kilo Code CLI",
+    executables: ["kilo"],
+    docs: [
+        "https://github.com/Kilo-Org/kilocode/blob/main/packages/kilo-docs/pages/customize/agents-md.md",
+        "https://github.com/Kilo-Org/kilocode/blob/main/packages/kilo-docs/pages/customize/skills.md",
+        "https://github.com/Kilo-Org/kilocode/blob/main/packages/opencode/src/kilocode/docs/migration.md",
+    ],
+    schemaUrl: "https://app.kilo.ai/config.json",
+    configPath: "kilo.json",
+    resourceRoot: ".kilo",
+    notes: [
+        "Kilo's CLI is an OpenCode-derived harness; this adapter shares the OpenCode compiler and changes only native paths, schema, identity, and documentation.",
+        "Tool hooks compile into a Kilo TypeScript plugin; non-tool lifecycle events are not emitted.",
+    ],
+});

package/dist/harness-configuration/adapters/kimi.js

@@ -0,0 +1,148 @@
+import { markdownWithFrontmatter } from "../core/frontmatter.js";
+import { descriptor } from "./descriptor.js";
+import { agentDocuments, commandSkillArtifacts, enabledHooks, secretValue, skillArtifacts, } from "./shared.js";
+import { nativeTools } from "./tools.js";
+function remoteHeaders(server) {
+    const headers = {};
+    let bearerTokenEnvVar;
+    for (const [name, value] of Object.entries(server.headers)) {
+        if (name.toLowerCase() === "authorization"
+            && typeof value !== "string"
+            && value.default === undefined) {
+            bearerTokenEnvVar = value.fromEnv;
+            continue;
+        }
+        headers[name] = secretValue(value);
+    }
+    return {
+        ...(Object.keys(headers).length > 0 ? { headers } : {}),
+        ...(bearerTokenEnvVar === undefined ? {} : { bearerTokenEnvVar }),
+    };
+}
+function kimiMcpServer(server) {
+    const common = {
+        enabled: server.enabled,
+        ...(server.timeoutMs === undefined
+            ? {}
+            : {
+                startupTimeoutMs: server.timeoutMs,
+                toolTimeoutMs: server.timeoutMs,
+            }),
+        ...(server.enabledTools?.length ? { enabledTools: server.enabledTools } : {}),
+        ...(server.disabledTools?.length ? { disabledTools: server.disabledTools } : {}),
+    };
+    if (server.transport === "stdio") {
+        return {
+            transport: "stdio",
+            command: server.command,
+            ...(server.args.length ? { args: server.args } : {}),
+            ...(Object.keys(server.env).length
+                ? {
+                    env: Object.fromEntries(Object.entries(server.env).map(([key, value]) => [key, secretValue(value)])),
+                }
+                : {}),
+            ...(server.cwd ? { cwd: server.cwd } : {}),
+            ...common,
+        };
+    }
+    return {
+        transport: server.transport === "sse" ? "sse" : "http",
+        url: server.url,
+        ...remoteHeaders(server),
+        ...common,
+    };
+}
+function kimiMcpMap(context) {
+    return Object.fromEntries(Object.entries(context.config.mcp.servers).map(([name, server]) => [
+        name,
+        kimiMcpServer(server),
+    ]));
+}
+export const kimiAdapter = {
+    descriptor: descriptor("kimi", "Kimi Code CLI", ["kimi"], [
+        "https://github.com/MoonshotAI/kimi-code/blob/main/docs/en/customization/skills.md",
+        "https://github.com/MoonshotAI/kimi-code/blob/main/docs/en/customization/mcp.md",
+        "https://github.com/MoonshotAI/kimi-code/blob/main/docs/en/customization/hooks.md",
+        "https://github.com/MoonshotAI/kimi-code/blob/main/docs/en/customization/agents.md",
+    ], {
+        instructions: "portable",
+        rules: "portable",
+        skills: "portable",
+        mcp: "native",
+        hooks: "lossy",
+        agents: "native",
+        commands: "translated",
+        permissions: "lossy",
+    }, [
+        "Kimi discovers project Agent Skills from .agents/skills, so canonical skills remain shared rather than copied.",
+        "Commands compile to Agent Skills and remain available through Kimi's /skill:<name> interface.",
+        "Kimi hooks and permanent permission rules live in the user-level config.toml; Canonfig does not mutate that profile-scoped file from a project projection.",
+    ], "2026-08-26"),
+    async build(context) {
+        const artifacts = [];
+        const diagnostics = [];
+        if (Object.keys(context.config.mcp.servers).length > 0) {
+            artifacts.push({
+                kind: "json",
+                path: ".kimi-code/mcp.json",
+                owner: "kimi",
+                operations: [{
+                        kind: "managed-map",
+                        path: ["mcpServers"],
+                        entries: kimiMcpMap(context),
+                        collision: "error",
+                    }],
+            });
+        }
+        for (const { agent, content } of await agentDocuments(context)) {
+            const tools = nativeTools("kimi", agent);
+            artifacts.push({
+                kind: "replace",
+                path: `.kimi-code/agents/${agent.id}.md`,
+                owner: "kimi",
+                content: markdownWithFrontmatter({
+                    name: agent.id,
+                    description: agent.description,
+                    ...(agent.model === "inherit" ? {} : { model: agent.model }),
+                    tools,
+                    ...(!agent.writable && tools.some((tool) => tool === "Edit" || tool === "Write")
+                        ? { disallowedTools: ["Edit", "Write"] }
+                        : {}),
+                }, content),
+            });
+        }
+        const commonSkillPaths = new Set((await skillArtifacts(context, ".agents/skills", "common"))
+            .map((artifact) => artifact.path));
+        for (const artifact of await commandSkillArtifacts(context, ".agents/skills", "kimi")) {
+            if (commonSkillPaths.has(artifact.path)) {
+                diagnostics.push({
+                    level: "error",
+                    code: "TRANSLATED_SKILL_COLLISION",
+                    target: "kimi",
+                    path: artifact.path,
+                    message: `Kimi command output collides with a canonical skill at ${artifact.path}; rename the skill or command.`,
+                });
+            }
+            else {
+                artifacts.push(artifact);
+            }
+        }
+        if (enabledHooks(context).length > 0) {
+            diagnostics.push({
+                level: "warning",
+                code: "KIMI_PROFILE_HOOKS_REQUIRED",
+                target: "kimi",
+                message: "Kimi Code hooks are stored in the user-level config.toml, so project hooks were not installed automatically.",
+            });
+        }
+        if (context.config.permissions.rules.length > 0) {
+            diagnostics.push({
+                level: "warning",
+                code: "KIMI_PROFILE_PERMISSIONS_REQUIRED",
+                target: "kimi",
+                message: "Kimi Code permanent permission rules are profile-scoped; canonical project permission rules were not installed automatically.",
+            });
+        }
+        return { artifacts, diagnostics };
+    },
+};

package/dist/harness-configuration/adapters/omp.js

@@ -0,0 +1,64 @@
+import { descriptor } from "./descriptor.js";
+import { agentDocuments, agentMarkdown, commandDocuments, commandMarkdown, enabledHooks, hasEnabledMcpServers, jsonMcpArtifact, ruleDocuments, ruleMarkdown, skillArtifacts, standardMcpProjectionDiagnostics, } from "./shared.js";
+import { nativeTools } from "./tools.js";
+import { PI_PLUGIN_EVENT_MAP, piPluginSource } from "../templates/runtime.js";
+const OMP_PLUGIN_EVENTS = new Set(Object.keys(PI_PLUGIN_EVENT_MAP));
+export const ompAdapter = {
+    descriptor: descriptor("oh-my-pi", "Oh My Pi", ["omp"], [
+        "https://github.com/can1357/oh-my-pi/blob/main/docs/config-usage.md",
+        "https://github.com/can1357/oh-my-pi/blob/main/docs/mcp-config.md",
+        "https://github.com/can1357/oh-my-pi/blob/main/docs/hooks.md",
+    ], {
+        instructions: "portable",
+        rules: "native",
+        skills: "native",
+        mcp: "native",
+        hooks: "shim",
+        agents: "native",
+        commands: "native",
+    }, ["Lifecycle hooks compile to an executable Oh My Pi extension."]),
+    async build(context) {
+        const artifacts = [];
+        const diagnostics = [];
+        artifacts.push(...await skillArtifacts(context, ".omp/skills", "oh-my-pi"));
+        if (hasEnabledMcpServers(context)) {
+            diagnostics.push(...standardMcpProjectionDiagnostics(context, "oh-my-pi"));
+            artifacts.push(jsonMcpArtifact(".omp/mcp.json", "oh-my-pi", context));
+        }
+        const hooks = enabledHooks(context);
+        const supportedHooks = hooks.filter((hook) => OMP_PLUGIN_EVENTS.has(hook.event));
+        for (const hook of hooks) {
+            if (!OMP_PLUGIN_EVENTS.has(hook.event)) {
+                diagnostics.push({
+                    level: "warning",
+                    code: "HOOK_EVENT_UNSUPPORTED",
+                    target: "oh-my-pi",
+                    message: `Oh My Pi's generated extension cannot map hook event ${hook.event}; it was skipped.`,
+                });
+            }
+        }
+        if (supportedHooks.length > 0) {
+            artifacts.push({
+                kind: "replace",
+                path: ".omp/extensions/canonfig.ts",
+                owner: "oh-my-pi",
+                content: piPluginSource("oh-my-pi", supportedHooks),
+            });
+        }
+        for (const { rule, content } of await ruleDocuments(context)) {
+            artifacts.push({ kind: "replace", path: `.omp/rules/${rule.id}.md`, owner: "oh-my-pi", content: ruleMarkdown(rule, content) });
+        }
+        for (const { agent, content } of await agentDocuments(context)) {
+            artifacts.push({
+                kind: "replace",
+                path: `.omp/agents/${agent.id}.md`,
+                owner: "oh-my-pi",
+                content: agentMarkdown(agent, content, nativeTools("oh-my-pi", agent)),
+            });
+        }
+        for (const { command, content } of await commandDocuments(context)) {
+            artifacts.push({ kind: "replace", path: `.omp/commands/${command.id}.md`, owner: "oh-my-pi", content: commandMarkdown(command, content) });
+        }
+        return { artifacts, diagnostics };
+    },
+};

package/dist/harness-configuration/adapters/open-code-family.js

@@ -0,0 +1,94 @@
+import { markdownWithFrontmatter } from "../core/frontmatter.js";
+import { openCodePluginSource } from "../templates/runtime.js";
+import { descriptor } from "./descriptor.js";
+import { agentDocuments, commandDocuments, commandMarkdown, enabledHooks, enabledMcpServerEntries, openCodeMcpMap, skillArtifacts, } from "./shared.js";
+import { nativeTools, nativeToolsForCapabilities } from "./tools.js";
+export function createOpenCodeFamilyAdapter(definition) {
+    return {
+        descriptor: descriptor(definition.id, definition.name, definition.executables, definition.docs, {
+            instructions: "portable",
+            rules: "portable",
+            skills: "native",
+            mcp: "native",
+            hooks: "shim",
+            agents: "native",
+            commands: "native",
+        }, definition.notes, "2026-08-26"),
+        async build(context) {
+            const artifacts = [];
+            const diagnostics = [];
+            const root = definition.resourceRoot;
+            artifacts.push(...await skillArtifacts(context, `${root}/skills`, definition.id));
+            if (Object.keys(context.config.mcp.servers).length > 0) {
+                artifacts.push({
+                    kind: "json",
+                    path: definition.configPath,
+                    owner: definition.id,
+                    operations: [{
+                            kind: "managed-map",
+                            path: ["mcp"],
+                            entries: openCodeMcpMap(context),
+                            collision: "error",
+                        }],
+                }, {
+                    kind: "json",
+                    path: definition.configPath,
+                    owner: definition.id,
+                    rootDefaults: { $schema: definition.schemaUrl },
+                    operations: [],
+                });
+            }
+            const hooks = enabledHooks(context);
+            const supportedHooks = hooks.filter((hook) => hook.event === "before_tool" || hook.event === "after_tool");
+            for (const hook of hooks) {
+                if (hook.event !== "before_tool" && hook.event !== "after_tool") {
+                    diagnostics.push({
+                        level: "warning",
+                        code: "HOOK_EVENT_UNSUPPORTED",
+                        target: definition.id,
+                        message: `${definition.name}'s generated plugin cannot map hook event ${hook.event}; it was skipped.`,
+                    });
+                }
+            }
+            if (supportedHooks.length > 0) {
+                artifacts.push({
+                    kind: "replace",
+                    path: `${root}/plugins/canonfig.ts`,
+                    owner: definition.id,
+                    content: openCodePluginSource(definition.id, supportedHooks),
+                });
+            }
+            const readOnlyTools = new Set(nativeToolsForCapabilities(definition.id, ["read", "search"]));
+            const mcpServerNames = enabledMcpServerEntries(context).map(([name]) => name);
+            for (const { agent, content } of await agentDocuments(context)) {
+                const permissions = Object.fromEntries(nativeTools(definition.id, agent).map((tool) => [
+                    tool,
+                    agent.writable || readOnlyTools.has(tool) ? "allow" : "deny",
+                ]));
+                for (const serverName of mcpServerNames) {
+                    permissions[`${serverName}_*`] = agent.tools.includes("mcp") ? "allow" : "deny";
+                }
+                artifacts.push({
+                    kind: "replace",
+                    path: `${root}/agents/${agent.id}.md`,
+                    owner: definition.id,
+                    content: markdownWithFrontmatter({
+                        description: agent.description,
+                        mode: "subagent",
+                        ...(agent.model === "inherit" ? {} : { model: agent.model }),
+                        permission: permissions,
+                    }, content),
+                });
+            }
+            for (const { command, content } of await commandDocuments(context)) {
+                artifacts.push({
+                    kind: "replace",
+                    path: `${root}/commands/${command.id}.md`,
+                    owner: definition.id,
+                    content: commandMarkdown(command, content),
+                });
+            }
+            return { artifacts, diagnostics };
+        },
+    };
+}

package/dist/harness-configuration/adapters/opencode.js

@@ -0,0 +1,18 @@
+import { createOpenCodeFamilyAdapter } from "./open-code-family.js";
+export const opencodeAdapter = createOpenCodeFamilyAdapter({
+    id: "opencode",
+    name: "OpenCode",
+    executables: ["opencode"],
+    docs: [
+        "https://opencode.ai/docs/config/",
+        "https://opencode.ai/docs/agents/",
+        "https://opencode.ai/docs/skills/",
+        "https://opencode.ai/docs/plugins/",
+    ],
+    schemaUrl: "https://opencode.ai/config.json",
+    configPath: "opencode.json",
+    resourceRoot: ".opencode",
+    notes: [
+        "Tool hooks compile into an OpenCode TypeScript plugin; non-tool lifecycle events are not emitted.",
+    ],
+});

package/dist/harness-configuration/adapters/pi.js

@@ -0,0 +1,93 @@
+import { descriptor } from "./descriptor.js";
+import { agentSkillArtifacts, commandDocuments, commandMarkdown, enabledHooks, hasEnabledMcpServers, piMcpMap, ruleDocuments, ruleMarkdown, skillArtifacts, } from "./shared.js";
+import { PI_PLUGIN_EVENT_MAP, piPluginSource } from "../templates/runtime.js";
+const PI_PLUGIN_EVENTS = new Set(Object.keys(PI_PLUGIN_EVENT_MAP));
+function mcpPackageOption(options) {
+    if (options.mcpPackage === false)
+        return false;
+    if (typeof options.mcpPackage === "string" && options.mcpPackage.trim())
+        return options.mcpPackage.trim();
+    return "npm:pi-mcp-extension";
+}
+export const piAdapter = {
+    descriptor: descriptor("pi", "Pi Coding Agent", ["pi"], [
+        "https://pi.dev/docs/latest/settings",
+        "https://pi.dev/docs/latest/extensions",
+        "https://pi.dev/docs/latest/skills",
+    ], {
+        instructions: "portable",
+        rules: "translated",
+        skills: "native",
+        mcp: "shim",
+        hooks: "shim",
+        agents: "lossy",
+        commands: "native",
+    }, [
+        "Pi does not ship a core MCP client; Canonfig writes a compatible MCP file and registers a configurable third-party package.",
+        "Canonical agents compile to Agent Skills because Pi has no equivalent static subagent manifest.",
+    ]),
+    async build(context) {
+        const artifacts = [];
+        const diagnostics = [];
+        artifacts.push(...await skillArtifacts(context, ".pi/skills", "pi"));
+        if (hasEnabledMcpServers(context)) {
+            artifacts.push({
+                kind: "json",
+                path: ".pi/mcp.json",
+                owner: "pi",
+                operations: [{ kind: "managed-map", path: ["mcpServers"], entries: piMcpMap(context), collision: "error" }],
+            });
+            const mcpPackage = mcpPackageOption(context.targetOptions);
+            if (mcpPackage === false) {
+                diagnostics.push({
+                    level: "warning",
+                    code: "PI_MCP_PACKAGE_DISABLED",
+                    target: "pi",
+                    message: "Pi MCP output was generated, but no MCP extension package will be registered because targets.pi.options.mcpPackage is false.",
+                });
+            }
+            else {
+                artifacts.push({
+                    kind: "json",
+                    path: ".pi/settings.json",
+                    owner: "pi",
+                    operations: [{ kind: "managed-array", path: ["packages"], values: [mcpPackage] }],
+                });
+                diagnostics.push({
+                    level: "warning",
+                    code: "PI_THIRD_PARTY_MCP",
+                    target: "pi",
+                    message: `Pi MCP support depends on the executable third-party package ${mcpPackage}; review and trust it before loading project resources.`,
+                });
+            }
+        }
+        const hooks = enabledHooks(context);
+        const supportedHooks = hooks.filter((hook) => PI_PLUGIN_EVENTS.has(hook.event));
+        for (const hook of hooks) {
+            if (!PI_PLUGIN_EVENTS.has(hook.event)) {
+                diagnostics.push({
+                    level: "warning",
+                    code: "HOOK_EVENT_UNSUPPORTED",
+                    target: "pi",
+                    message: `Pi's generated extension cannot map hook event ${hook.event}; it was skipped.`,
+                });
+            }
+        }
+        if (supportedHooks.length > 0) {
+            artifacts.push({
+                kind: "replace",
+                path: ".pi/extensions/canonfig.ts",
+                owner: "pi",
+                content: piPluginSource("pi", supportedHooks),
+            });
+        }
+        for (const { rule, content } of await ruleDocuments(context)) {
+            artifacts.push({ kind: "replace", path: `.pi/rules/${rule.id}.md`, owner: "pi", content: ruleMarkdown(rule, content) });
+        }
+        for (const { command, content } of await commandDocuments(context)) {
+            artifacts.push({ kind: "replace", path: `.pi/prompts/${command.id}.md`, owner: "pi", content: commandMarkdown(command, content) });
+        }
+        artifacts.push(...await agentSkillArtifacts(context, ".pi/skills", "pi"));
+        return { artifacts, diagnostics };
+    },
+};