@microck/canonfig 2.0.0 → 2.1.0

package/README.md

@@ -55,7 +55,7 @@ Required; the current executor never fetches or builds source code.
 Install the exact public package version on Linux, macOS, or Windows:
 
 ```bash
-npm install --global @microck/canonfig@2.0.0
+npm install --global @microck/canonfig@2.1.0
 canonfig --version
 ```
 

package/dist/cli/cli.js

@@ -11,7 +11,7 @@ import { renderCliResult, } from "./render.js";
 import { SourceCommands, } from "./source-commands.js";
 export const programName = "canonfig";
 export const programDisplayName = "Canonfig";
-export const programVersion = "2.0.0";
+export const programVersion = "2.1.0";
 export const helpText = `${programDisplayName} ${programVersion}
 
 Usage: ${programName} <command> [options]

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

@@ -0,0 +1,87 @@
+import { descriptor } from "./descriptor.js";
+import { agentDocuments, commandSkillArtifacts, enabledHooks, hasEnabledMcpServers, ruleDocuments, ruleMarkdown, skillArtifacts, standardMcpMap, standardMcpProjectionDiagnostics, } from "./shared.js";
+import { nativeTools } from "./tools.js";
+import { AMP_PLUGIN_EVENT_MAP, ampPluginSource } from "../templates/runtime.js";
+const AMP_PLUGIN_EVENTS = new Set(Object.keys(AMP_PLUGIN_EVENT_MAP));
+export const ampAdapter = {
+    descriptor: descriptor("amp", "Amp", ["amp"], [
+        "https://ampcode.com/manual",
+        "https://ampcode.com/manual#mcp",
+        "https://ampcode.com/manual#agent-skills",
+        "https://ampcode.com/manual#plugins",
+    ], {
+        instructions: "portable",
+        rules: "translated",
+        skills: "portable",
+        mcp: "native",
+        hooks: "shim",
+        agents: "translated",
+        commands: "translated",
+    }, [
+        "Hooks and custom subagents compile into an Amp TypeScript plugin.",
+        "Commands compile to Agent Skills so they remain invokable without relying on an unstable command manifest.",
+    ]),
+    async build(context) {
+        const artifacts = [];
+        const diagnostics = [];
+        if (hasEnabledMcpServers(context)) {
+            diagnostics.push(...standardMcpProjectionDiagnostics(context, "amp", false));
+            artifacts.push({
+                kind: "json",
+                path: ".amp/settings.json",
+                owner: "amp",
+                operations: [{
+                        kind: "managed-map",
+                        path: ["amp.mcpServers"],
+                        entries: standardMcpMap(context, false),
+                        collision: "error",
+                    }],
+            });
+        }
+        const agents = await agentDocuments(context);
+        const hooks = enabledHooks(context);
+        const supportedHooks = hooks.filter((hook) => AMP_PLUGIN_EVENTS.has(hook.event));
+        for (const hook of hooks) {
+            if (!AMP_PLUGIN_EVENTS.has(hook.event)) {
+                diagnostics.push({
+                    level: "warning",
+                    code: "HOOK_EVENT_UNSUPPORTED",
+                    target: "amp",
+                    message: `Amp's generated plugin cannot map hook event ${hook.event}; it was skipped.`,
+                });
+            }
+        }
+        if (supportedHooks.length > 0 || agents.length > 0) {
+            artifacts.push({
+                kind: "replace",
+                path: ".amp/plugins/canonfig.ts",
+                owner: "amp",
+                content: ampPluginSource(supportedHooks, agents.map(({ agent, content }) => ({ agent, content, tools: nativeTools("amp", agent) }))),
+            });
+        }
+        for (const { rule, content } of await ruleDocuments(context)) {
+            artifacts.push({
+                kind: "replace",
+                path: `.amp/rules/${rule.id}.md`,
+                owner: "amp",
+                content: ruleMarkdown(rule, content),
+            });
+        }
+        const commonSkillPaths = new Set((await skillArtifacts(context, ".agents/skills", "common")).map((artifact) => artifact.path));
+        for (const artifact of await commandSkillArtifacts(context, ".agents/skills", "amp")) {
+            if (commonSkillPaths.has(artifact.path)) {
+                diagnostics.push({
+                    level: "error",
+                    code: "TRANSLATED_SKILL_COLLISION",
+                    target: "amp",
+                    path: artifact.path,
+                    message: `Amp command output collides with a canonical skill at ${artifact.path}; rename the skill or command.`,
+                });
+            }
+            else {
+                artifacts.push(artifact);
+            }
+        }
+        return { artifacts, diagnostics };
+    },
+};

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

@@ -0,0 +1,50 @@
+import { descriptor } from "./descriptor.js";
+import { agentSkillArtifacts, antigravityHooks, antigravityMcpMap, commandSkillArtifacts, enabledHooks, hasEnabledMcpServers, ruleDocuments, ruleMarkdown, skillArtifacts, } from "./shared.js";
+export const antigravityAdapter = {
+    descriptor: descriptor("antigravity", "Google Antigravity CLI", ["agy"], ["https://antigravity.google/docs/mcp", "https://antigravity.google/docs/hooks", "https://antigravity.google/docs/gcli-migration"], { instructions: "portable", rules: "native", skills: "portable", mcp: "native", hooks: "native", agents: "translated", commands: "translated" }, ["Canonical agents and commands compile to Agent Skills; Antigravity exposes subagents separately from portable agent manifests."]),
+    async build(context) {
+        const artifacts = [];
+        const diagnostics = [];
+        if (hasEnabledMcpServers(context)) {
+            artifacts.push({
+                kind: "json", path: ".agents/mcp_config.json", owner: "antigravity",
+                operations: [{ kind: "managed-map", path: ["mcpServers"], entries: antigravityMcpMap(context), collision: "error" }],
+            });
+        }
+        if (enabledHooks(context).length > 0) {
+            const compiled = antigravityHooks(context);
+            diagnostics.push(...compiled.diagnostics);
+            if (Object.keys(compiled.entries).length > 0) {
+                artifacts.push({
+                    kind: "json", path: ".agents/hooks.json", owner: "antigravity",
+                    operations: [{ kind: "managed-map", path: [], entries: compiled.entries, collision: "error" }],
+                });
+            }
+        }
+        for (const { rule, content } of await ruleDocuments(context)) {
+            artifacts.push({ kind: "replace", path: `.agents/rules/${rule.id}.md`, owner: "antigravity", content: ruleMarkdown(rule, content, { trigger: rule.paths.length ? "glob" : "always" }) });
+        }
+        const commonSkills = await skillArtifacts(context, ".agents/skills", "common");
+        artifacts.push(...commonSkills);
+        const occupiedSkillPaths = new Set(commonSkills.map((artifact) => artifact.path));
+        const translatedSkills = [
+            ...await agentSkillArtifacts(context, ".agents/skills", "antigravity"),
+            ...await commandSkillArtifacts(context, ".agents/skills", "antigravity"),
+        ];
+        for (const artifact of translatedSkills) {
+            if (occupiedSkillPaths.has(artifact.path)) {
+                diagnostics.push({
+                    level: "error",
+                    code: "TRANSLATED_SKILL_COLLISION",
+                    target: "antigravity",
+                    path: artifact.path,
+                    message: `Antigravity translated skill output collides at ${artifact.path}; rename the canonical skill, agent, or command.`,
+                });
+                continue;
+            }
+            occupiedSkillPaths.add(artifact.path);
+            artifacts.push(artifact);
+        }
+        return { artifacts, diagnostics };
+    },
+};

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

@@ -0,0 +1,43 @@
+import { descriptor } from "./descriptor.js";
+import { agentDocuments, agentMarkdown, claudeStyleHooks, commandDocuments, commandMarkdown, enabledHooks, enabledMcpServerEntries, ruleDocuments, ruleMarkdown, skillArtifacts, standardMcpProjectionDiagnostics, } from "./shared.js";
+import { nativeTools } from "./tools.js";
+export const claudeAdapter = {
+    descriptor: descriptor("claude-code", "Claude Code", ["claude"], ["https://docs.anthropic.com/en/docs/claude-code/settings", "https://docs.anthropic.com/en/docs/claude-code/hooks"], { instructions: "translated", rules: "native", skills: "native", mcp: "native", hooks: "native", agents: "native", commands: "native" }, ["CLAUDE.md is generated as a small bridge to the canonical AGENTS.md."]),
+    async build(context) {
+        const artifacts = [{
+                kind: "managed-text", path: "CLAUDE.md", owner: "claude-code", marker: "instructions-import",
+                comments: "html", placement: "start", content: "@AGENTS.md",
+            }];
+        const diagnostics = standardMcpProjectionDiagnostics(context, "claude-code");
+        artifacts.push(...await skillArtifacts(context, ".claude/skills", "claude-code"));
+        for (const { rule, content } of await ruleDocuments(context)) {
+            artifacts.push({ kind: "replace", path: `.claude/rules/${rule.id}.md`, owner: "claude-code", content: ruleMarkdown(rule, content, rule.paths.length ? { paths: rule.paths } : {}) });
+        }
+        if (enabledHooks(context).length > 0) {
+            const compiled = claudeStyleHooks(context);
+            diagnostics.push(...compiled.diagnostics);
+            if (Object.keys(compiled.hooks).length > 0) {
+                artifacts.push({
+                    kind: "json", path: ".claude/settings.json", owner: "claude-code",
+                    operations: [{ kind: "managed-hooks", path: ["hooks"], hooks: compiled.hooks, marker: ".canonfig/.runtime/hook-runner.mjs" }],
+                });
+            }
+        }
+        for (const { agent, content } of await agentDocuments(context)) {
+            const tools = nativeTools("claude-code", agent);
+            if (agent.tools.includes("mcp")) {
+                tools.push(...enabledMcpServerEntries(context).map(([name]) => `mcp__${name}`));
+            }
+            artifacts.push({
+                kind: "replace",
+                path: `.claude/agents/${agent.id}.md`,
+                owner: "claude-code",
+                content: agentMarkdown(agent, content, [...new Set(tools)]),
+            });
+        }
+        for (const { command, content } of await commandDocuments(context)) {
+            artifacts.push({ kind: "replace", path: `.claude/commands/${command.id}.md`, owner: "claude-code", content: commandMarkdown(command, content) });
+        }
+        return { artifacts, diagnostics };
+    },
+};

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

@@ -0,0 +1,60 @@
+import { descriptor } from "./descriptor.js";
+import { agentDocuments, CODEX_EVENT_MAP, codexMcpDiagnostics, commandSkillArtifacts, enabledHooks, mcpToml, claudeStyleHooks, } from "./shared.js";
+function tomlString(value) { return JSON.stringify(value); }
+function tomlMultiline(value) {
+    const escaped = value.replaceAll("\\", "\\\\").replaceAll('"""', '\\"\\"\\"');
+    return `"""\n${escaped.trim()}\n"""`;
+}
+export const codexAdapter = {
+    descriptor: descriptor("codex", "OpenAI Codex", ["codex"], [
+        "https://developers.openai.com/codex/config-reference",
+        "https://developers.openai.com/codex/subagents",
+        "https://developers.openai.com/codex/hooks",
+    ], {
+        instructions: "portable",
+        rules: "translated",
+        skills: "portable",
+        mcp: "native",
+        hooks: "native",
+        agents: "native",
+        commands: "translated",
+    }, ["Commands compile to Agent Skills because Codex uses skills as the portable command surface."]),
+    async build(context) {
+        const artifacts = [];
+        const diagnostics = [];
+        const mcp = mcpToml(context);
+        if (mcp) {
+            diagnostics.push(...codexMcpDiagnostics(context));
+            artifacts.push({
+                kind: "toml", path: ".codex/config.toml", owner: "codex",
+                blocks: [{ marker: "mcp-servers", content: mcp }],
+                description: "Codex project MCP servers",
+            });
+        }
+        if (enabledHooks(context).length > 0) {
+            const compiled = claudeStyleHooks(context, CODEX_EVENT_MAP);
+            diagnostics.push(...compiled.diagnostics);
+            if (Object.keys(compiled.hooks).length > 0) {
+                artifacts.push({
+                    kind: "json", path: ".codex/hooks.json", owner: "codex",
+                    rootDefaults: { version: 1 },
+                    operations: [{ kind: "managed-hooks", path: ["hooks"], hooks: compiled.hooks, marker: ".canonfig/.runtime/hook-runner.mjs" }],
+                    description: "Codex lifecycle hooks",
+                });
+            }
+        }
+        for (const { agent, content } of await agentDocuments(context)) {
+            const lines = [
+                `name = ${tomlString(agent.id)}`,
+                `description = ${tomlString(agent.description)}`,
+                ...(agent.model === "inherit" ? [] : [`model = ${tomlString(agent.model)}`]),
+                `sandbox_mode = ${tomlString(agent.writable ? "workspace-write" : "read-only")}`,
+                `developer_instructions = ${tomlMultiline(content)}`,
+                "",
+            ];
+            artifacts.push({ kind: "replace", path: `.codex/agents/${agent.id}.toml`, owner: "codex", content: lines.join("\n") });
+        }
+        artifacts.push(...await commandSkillArtifacts(context, ".codex/skills", "codex"));
+        return { artifacts, diagnostics };
+    },
+};

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

@@ -0,0 +1,79 @@
+import { descriptor } from "./descriptor.js";
+import { agentDocuments, commandSkillArtifacts, copilotHooks, enabledHooks, ruleDocuments, skillArtifacts, standardMcpProjectionDiagnostics, } from "./shared.js";
+import { nativeTools } from "./tools.js";
+import { markdownWithFrontmatter } from "../core/frontmatter.js";
+export const copilotAdapter = {
+    descriptor: descriptor("copilot-cli", "GitHub Copilot CLI", ["copilot"], [
+        "https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-custom-instructions",
+        "https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-skills",
+        "https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-hooks",
+        "https://docs.github.com/en/copilot/customizing-copilot/adding-repository-custom-instructions-for-github-copilot",
+    ], {
+        instructions: "portable",
+        rules: "native",
+        skills: "native",
+        mcp: "portable",
+        hooks: "native",
+        agents: "native",
+        commands: "translated",
+    }, ["The shared repository .mcp.json is used for MCP; commands compile to Agent Skills."]),
+    async build(context) {
+        const artifacts = [];
+        const diagnostics = standardMcpProjectionDiagnostics(context, "copilot-cli");
+        const commonSkills = await skillArtifacts(context, ".github/skills", "copilot-cli");
+        artifacts.push(...commonSkills);
+        const occupiedSkillPaths = new Set(commonSkills.map((artifact) => artifact.path));
+        if (enabledHooks(context).length > 0) {
+            const compiled = copilotHooks(context);
+            diagnostics.push(...compiled.diagnostics);
+            if (Object.keys(compiled.hooks).length > 0) {
+                artifacts.push({
+                    kind: "json",
+                    path: ".github/hooks/canonfig.json",
+                    owner: "copilot-cli",
+                    rootDefaults: { version: 1 },
+                    operations: [{ kind: "managed-hooks", path: ["hooks"], hooks: compiled.hooks, marker: ".canonfig/.runtime/hook-runner.mjs" }],
+                });
+            }
+        }
+        for (const { rule, content } of await ruleDocuments(context)) {
+            artifacts.push({
+                kind: "replace",
+                path: `.github/instructions/${rule.id}.instructions.md`,
+                owner: "copilot-cli",
+                content: markdownWithFrontmatter({
+                    description: rule.description ?? `Canonfig rule: ${rule.id}`,
+                    applyTo: rule.paths.length > 0 ? rule.paths.join(",") : "**",
+                }, content),
+            });
+        }
+        for (const { agent, content } of await agentDocuments(context)) {
+            artifacts.push({
+                kind: "replace",
+                path: `.github/agents/${agent.id}.agent.md`,
+                owner: "copilot-cli",
+                content: markdownWithFrontmatter({
+                    name: agent.id,
+                    description: agent.description,
+                    ...(agent.model === "inherit" ? {} : { model: agent.model }),
+                    tools: nativeTools("copilot-cli", agent),
+                }, content),
+            });
+        }
+        for (const artifact of await commandSkillArtifacts(context, ".github/skills", "copilot-cli")) {
+            if (occupiedSkillPaths.has(artifact.path)) {
+                diagnostics.push({
+                    level: "error",
+                    code: "TRANSLATED_SKILL_COLLISION",
+                    target: "copilot-cli",
+                    path: artifact.path,
+                    message: `Copilot command output collides with a canonical skill at ${artifact.path}; rename the skill or command.`,
+                });
+                continue;
+            }
+            occupiedSkillPaths.add(artifact.path);
+            artifacts.push(artifact);
+        }
+        return { artifacts, diagnostics };
+    },
+};

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

@@ -0,0 +1,67 @@
+import { descriptor } from "./descriptor.js";
+import { agentDocuments, agentMarkdown, commandDocuments, commandMarkdown, cursorHooks, enabledHooks, hasEnabledMcpServers, jsonMcpArtifact, ruleDocuments, skillArtifacts, standardMcpProjectionDiagnostics, } from "./shared.js";
+import { nativeTools } from "./tools.js";
+import { markdownWithFrontmatter } from "../core/frontmatter.js";
+export const cursorAdapter = {
+    descriptor: descriptor("cursor", "Cursor", ["cursor-agent", "agent"], [
+        "https://cursor.com/docs/cli/reference/configuration",
+        "https://cursor.com/docs/context/rules",
+        "https://cursor.com/docs/skills",
+        "https://cursor.com/docs/agent/hooks",
+    ], {
+        instructions: "portable",
+        rules: "native",
+        skills: "native",
+        mcp: "native",
+        hooks: "native",
+        agents: "native",
+        commands: "native",
+    }, ["Hook event availability is Cursor-version dependent; unsupported canonical events produce diagnostics."]),
+    async build(context) {
+        const artifacts = [];
+        const diagnostics = [];
+        artifacts.push(...await skillArtifacts(context, ".cursor/skills", "cursor"));
+        if (hasEnabledMcpServers(context)) {
+            diagnostics.push(...standardMcpProjectionDiagnostics(context, "cursor"));
+            artifacts.push(jsonMcpArtifact(".cursor/mcp.json", "cursor", context));
+        }
+        if (enabledHooks(context).length > 0) {
+            const compiled = cursorHooks(context);
+            diagnostics.push(...compiled.diagnostics);
+            if (Object.keys(compiled.hooks).length > 0) {
+                artifacts.push({
+                    kind: "json",
+                    path: ".cursor/hooks.json",
+                    owner: "cursor",
+                    rootDefaults: { version: 1 },
+                    operations: [{ kind: "managed-hooks", path: ["hooks"], hooks: compiled.hooks, marker: ".canonfig/.runtime/hook-runner.mjs" }],
+                });
+            }
+        }
+        for (const { rule, content } of await ruleDocuments(context)) {
+            const activation = rule.activation ?? (rule.paths.length > 0 ? "path" : "always");
+            artifacts.push({
+                kind: "replace",
+                path: `.cursor/rules/${rule.id}.mdc`,
+                owner: "cursor",
+                content: markdownWithFrontmatter({
+                    description: rule.description ?? `Canonfig rule: ${rule.id}`,
+                    globs: rule.paths.join(","),
+                    alwaysApply: activation === "always",
+                }, content),
+            });
+        }
+        for (const { agent, content } of await agentDocuments(context)) {
+            artifacts.push({
+                kind: "replace",
+                path: `.cursor/agents/${agent.id}.md`,
+                owner: "cursor",
+                content: agentMarkdown(agent, content, nativeTools("cursor", agent)),
+            });
+        }
+        for (const { command, content } of await commandDocuments(context)) {
+            artifacts.push({ kind: "replace", path: `.cursor/commands/${command.id}.md`, owner: "cursor", content: commandMarkdown(command, content) });
+        }
+        return { artifacts, diagnostics };
+    },
+};

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

@@ -0,0 +1,10 @@
+export function descriptor(id, name, executables, docs, capabilities, notes = [], verifiedAt = "2026-08-18") {
+    return {
+        id, name, executables, docs, verifiedAt,
+        capabilities: {
+            instructions: "portable", rules: "translated", skills: "portable", mcp: "native",
+            hooks: "native", agents: "native", commands: "native", permissions: "unsupported", ...capabilities,
+        },
+        ...(notes.length ? { notes } : {}),
+    };
+}

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

@@ -0,0 +1,66 @@
+import { descriptor } from "./descriptor.js";
+import { agentSkillArtifacts, claudeStyleHooks, commandSkillArtifacts, DEVIN_EVENT_MAP, enabledHooks, hasEnabledMcpServers, jsonMcpArtifact, ruleDocuments, ruleMarkdown, skillArtifacts, standardMcpProjectionDiagnostics, } from "./shared.js";
+export const devinAdapter = {
+    descriptor: descriptor("devin", "Devin CLI / Devin Local", ["devin"], [
+        "https://docs.devin.ai/cli/extensibility/configuration",
+        "https://docs.devin.ai/cli/extensibility/rules",
+        "https://docs.devin.ai/cli/extensibility/mcp",
+        "https://docs.devin.ai/cli/extensibility/hooks",
+        "https://docs.devin.ai/cli/extensibility/skills",
+    ], {
+        instructions: "portable",
+        rules: "native",
+        skills: "native",
+        mcp: "native",
+        hooks: "native",
+        agents: "translated",
+        commands: "translated",
+    }, ["Canonical agents and commands compile to Devin-discoverable Agent Skills."]),
+    async build(context) {
+        const artifacts = [];
+        const diagnostics = [];
+        const skills = await skillArtifacts(context, ".devin/skills", "devin");
+        artifacts.push(...skills);
+        if (hasEnabledMcpServers(context)) {
+            diagnostics.push(...standardMcpProjectionDiagnostics(context, "devin"));
+            artifacts.push(jsonMcpArtifact(".devin/mcp.json", "devin", context));
+        }
+        if (enabledHooks(context).length > 0) {
+            const compiled = claudeStyleHooks(context, DEVIN_EVENT_MAP);
+            diagnostics.push(...compiled.diagnostics);
+            if (Object.keys(compiled.hooks).length > 0) {
+                artifacts.push({
+                    kind: "json",
+                    path: ".devin/hooks.v1.json",
+                    owner: "devin",
+                    rootDefaults: { version: 1 },
+                    operations: [{ kind: "managed-hooks", path: ["hooks"], hooks: compiled.hooks, marker: ".canonfig/.runtime/hook-runner.mjs" }],
+                });
+            }
+        }
+        for (const { rule, content } of await ruleDocuments(context)) {
+            artifacts.push({ kind: "replace", path: `.devin/rules/${rule.id}.md`, owner: "devin", content: ruleMarkdown(rule, content) });
+        }
+        const occupiedSkillPaths = new Set(skills.map((artifact) => artifact.path));
+        const translated = [
+            ...await agentSkillArtifacts(context, ".devin/skills", "devin"),
+            ...await commandSkillArtifacts(context, ".devin/skills", "devin"),
+        ];
+        for (const artifact of translated) {
+            if (occupiedSkillPaths.has(artifact.path)) {
+                diagnostics.push({
+                    level: "error",
+                    code: "TRANSLATED_SKILL_COLLISION",
+                    target: "devin",
+                    path: artifact.path,
+                    message: `Devin translated skill output collides with another skill at ${artifact.path}; rename the canonical skill, agent, or command.`,
+                });
+            }
+            else {
+                occupiedSkillPaths.add(artifact.path);
+                artifacts.push(artifact);
+            }
+        }
+        return { artifacts, diagnostics };
+    },
+};

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

@@ -0,0 +1,32 @@
+import { descriptor } from "./descriptor.js";
+import { agentDocuments, agentMarkdown, claudeStyleHooks, commandDocuments, commandMarkdown, enabledHooks, hasEnabledMcpServers, jsonMcpArtifact, skillArtifacts, standardMcpProjectionDiagnostics, } from "./shared.js";
+import { nativeTools } from "./tools.js";
+export const droidAdapter = {
+    descriptor: descriptor("factory-droid", "Factory Droid CLI", ["droid"], ["https://docs.factory.ai/harness/hooks", "https://docs.factory.ai/harness/mcp", "https://docs.factory.ai/droid-cli/settings"], { rules: "portable", skills: "native" }),
+    async build(context) {
+        const artifacts = [];
+        const diagnostics = [];
+        artifacts.push(...await skillArtifacts(context, ".factory/skills", "factory-droid"));
+        if (hasEnabledMcpServers(context)) {
+            diagnostics.push(...standardMcpProjectionDiagnostics(context, "factory-droid"));
+            artifacts.push(jsonMcpArtifact(".factory/mcp.json", "factory-droid", context));
+        }
+        if (enabledHooks(context).length > 0) {
+            const compiled = claudeStyleHooks(context);
+            diagnostics.push(...compiled.diagnostics);
+            if (Object.keys(compiled.hooks).length > 0) {
+                artifacts.push({
+                    kind: "json", path: ".factory/hooks.json", owner: "factory-droid",
+                    operations: [{ kind: "managed-hooks", path: ["hooks"], hooks: compiled.hooks, marker: ".canonfig/.runtime/hook-runner.mjs" }],
+                });
+            }
+        }
+        for (const { agent, content } of await agentDocuments(context)) {
+            artifacts.push({ kind: "replace", path: `.factory/droids/${agent.id}.md`, owner: "factory-droid", content: agentMarkdown(agent, content, nativeTools("factory-droid", agent)) });
+        }
+        for (const { command, content } of await commandDocuments(context)) {
+            artifacts.push({ kind: "replace", path: `.factory/commands/${command.id}.md`, owner: "factory-droid", content: commandMarkdown(command, content) });
+        }
+        return { artifacts, diagnostics };
+    },
+};

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

@@ -0,0 +1,44 @@
+import { descriptor } from "./descriptor.js";
+import { agentDocuments, agentMarkdown, claudeStyleHooks, commandDocuments, commandMarkdown, enabledHooks, GROK_EVENT_MAP, grokMcpToml, ruleDocuments, skillArtifacts, } from "./shared.js";
+import { nativeTools } from "./tools.js";
+export const grokAdapter = {
+    descriptor: descriptor("grok-build", "Grok Build CLI", ["grok"], ["https://docs.x.ai/build/cli/reference", "https://docs.x.ai/build/features/skills-plugins-marketplaces", "https://docs.x.ai/build/features/mcp-servers", "https://docs.x.ai/build/features/hooks"], { instructions: "portable", rules: "portable", skills: "native", mcp: "native", hooks: "native", agents: "native", commands: "native" }, ["Project hooks require Grok workspace hook trust."]),
+    async build(context) {
+        const artifacts = [];
+        const diagnostics = [];
+        artifacts.push(...await skillArtifacts(context, ".grok/skills", "grok-build"));
+        const mcp = grokMcpToml(context);
+        if (mcp)
+            artifacts.push({ kind: "toml", path: ".grok/config.toml", owner: "grok-build", blocks: [{ marker: "mcp-servers", content: mcp }] });
+        if (enabledHooks(context).length > 0) {
+            const compiled = claudeStyleHooks(context, GROK_EVENT_MAP);
+            diagnostics.push(...compiled.diagnostics);
+            if (Object.keys(compiled.hooks).length > 0) {
+                artifacts.push({
+                    kind: "json", path: ".grok/hooks/canonfig.json", owner: "grok-build", rootDefaults: { version: 1 },
+                    operations: [{ kind: "managed-hooks", path: ["hooks"], hooks: compiled.hooks, marker: ".canonfig/.runtime/hook-runner.mjs" }],
+                });
+            }
+        }
+        for (const { agent, content } of await agentDocuments(context)) {
+            artifacts.push({ kind: "replace", path: `.grok/agents/${agent.id}.md`, owner: "grok-build", content: agentMarkdown(agent, content, nativeTools("grok-build", agent)) });
+        }
+        for (const { command, content } of await commandDocuments(context)) {
+            artifacts.push({ kind: "replace", path: `.grok/commands/${command.id}.md`, owner: "grok-build", content: commandMarkdown(command, content) });
+        }
+        for (const { rule, content } of await ruleDocuments(context)) {
+            if (rule.paths.length > 0) {
+                diagnostics.push({
+                    level: "warning",
+                    code: "RULE_SCOPE_LOST",
+                    target: "grok-build",
+                    path: `.canonfig/${rule.file}`,
+                    message: `Grok project rules cannot preserve Canonfig's path scope for ${rule.id}; the native rule file was skipped and the scoped AGENTS.md bridge remains authoritative.`,
+                });
+                continue;
+            }
+            artifacts.push({ kind: "replace", path: `.grok/rules/${rule.id}.md`, owner: "grok-build", content });
+        }
+        return { artifacts, diagnostics };
+    },
+};