@kuznai/inception-engine 0.17.0 → 0.19.0

package/dist/core/adapters/mcp.js

@@ -46,7 +46,7 @@ function buildMcpDeployAction(entry, agentId, resolvedTarget, confidence, mcpPat
         confidence,
     };
 }
-export function compileMcpServerActions(entry, detectedAgents, home, repo) {
+export function compileMcpServerActions(entry, detectedAgents, home, repo, workspace) {
     const actions = [];
     const warnings = [];
     const platform = getPlatformKey();
@@ -70,7 +70,7 @@ export function compileMcpServerActions(entry, detectedAgents, home, repo) {
             continue;
         }
         validateMcpServerConfigShape(entry.config, entry.name, agentId);
-        const rawTarget = resolvePlaceholders(support.path[platform], entry.name, home, repo);
+        const rawTarget = resolvePlaceholders(support.path[platform], entry.name, home, repo, workspace);
         const resolvedTarget = path.resolve(rawTarget);
         const confidence = agent.provenance.mcpConfig ?? "provisional";
         const mcpPatchKey = support.mcpPatchKey ?? "mcpServers";
@@ -78,7 +78,7 @@ export function compileMcpServerActions(entry, detectedAgents, home, repo) {
     }
     return { actions, warnings };
 }
-export function compileMcpServerReverts(entry, agentFilter, home, repo) {
+export function compileMcpServerReverts(entry, agentFilter, home, repo, workspace) {
     const actions = [];
     const platform = getPlatformKey();
     for (const agentId of entry.agents) {
@@ -90,7 +90,7 @@ export function compileMcpServerReverts(entry, agentFilter, home, repo) {
             support.status === "unsupported" ||
             support.status === "planned")
             continue;
-        const rawTarget = resolvePlaceholders(support.path[platform], entry.name, home, repo);
+        const rawTarget = resolvePlaceholders(support.path[platform], entry.name, home, repo, workspace);
         const target = path.resolve(rawTarget);
         if (isMarkdownTarget(target)) {
             actions.push({

package/dist/core/adapters/rules.d.ts

@@ -4,5 +4,5 @@ export interface RulesAdapterResult {
     actions: FileWriteDeployAction[];
     warnings: PlanWarning[];
 }
-export declare function compileAgentRuleActions(entry: AgentRuleEntry, sourceDir: string, resolvedSourceDir: string, realRoot: string, detectedAgents: AgentId[], home: string, repo?: string): Promise<RulesAdapterResult>;
-export declare function compileAgentRuleReverts(entry: AgentRuleEntry, agentFilter: AgentId[] | null, home: string, repo?: string): FileWriteRevertAction[];
+export declare function compileAgentRuleActions(entry: AgentRuleEntry, sourceDir: string, resolvedSourceDir: string, realRoot: string, detectedAgents: AgentId[], home: string, repo?: string, workspace?: string): Promise<RulesAdapterResult>;
+export declare function compileAgentRuleReverts(entry: AgentRuleEntry, agentFilter: AgentId[] | null, home: string, repo?: string, workspace?: string): FileWriteRevertAction[];

package/dist/core/adapters/rules.js

@@ -1,8 +1,64 @@
 import path from "node:path";
 import { AGENT_REGISTRY_BY_ID } from "../../config/agents.js";
 import { getPlatformKey, resolvePlaceholders } from "../resolve.js";
-import { validateAgentRuleMarkdownPath, validateSourceFile, validateSourcePath, } from "../validation.js";
-export async function compileAgentRuleActions(entry, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo) {
+import { validateAgentRuleMarkdownPath, validateInstructionFileRequirements, validateSourceFile, validateSourcePath, } from "../validation.js";
+function resolveRulesSupport(agentId, scope) {
+    const agent = AGENT_REGISTRY_BY_ID[agentId];
+    if (scope === "repo") {
+        return agent?.agentRulesRepoSupport ?? agent?.agentRulesSupport;
+    }
+    if (scope === "workspace") {
+        return (agent?.agentRulesWorkspaceSupport ??
+            agent?.agentRulesRepoSupport ??
+            agent?.agentRulesSupport);
+    }
+    return agent?.agentRulesSupport;
+}
+function resolveAgentTarget(agentId, entry, home, repo, platform, workspace, allTargetAgentIds) {
+    const support = resolveRulesSupport(agentId, entry.scope);
+    if (!support || support.status === "unsupported") {
+        return {
+            kind: "confidence",
+            message: `agentRules: agent "${agentId}" uses ${support?.schemaLabel ?? "an unsupported instruction schema"} (unsupported) and ${support?.status === "unsupported" ? support.reason : "does not expose a supported rules adapter"} — skipping "${entry.name}"`,
+        };
+    }
+    if (support.status === "planned") {
+        return {
+            kind: "confidence",
+            message: `agentRules: agent "${agentId}" rules support is planned via ${support.plannedSurface} — skipping "${entry.name}" until that surface is implemented`,
+        };
+    }
+    // shared-via: when requiresPrimary is set and the primary agent is absent
+    // from the target list, emit a guidance warning instead of deploying.
+    if (support.surfaceKind?.kind === "shared-via" &&
+        support.surfaceKind.requiresPrimary &&
+        allTargetAgentIds &&
+        !allTargetAgentIds.includes(support.surfaceKind.via)) {
+        return {
+            kind: "confidence",
+            message: `agentRules: agent "${agentId}" reads this surface via "${support.surfaceKind.via}" — add "${support.surfaceKind.via}" to the entry's agents list to deploy to this surface, or deploy via the "${support.surfaceKind.via}" agentRules target instead`,
+        };
+    }
+    if (entry.scope === "repo" && !repo) {
+        return {
+            kind: "confidence",
+            message: `agentRules: scope "repo" requires a repository path but none was resolved — skipping "${entry.name}" for agent "${agentId}"`,
+        };
+    }
+    if (entry.scope === "workspace" && !workspace && !repo) {
+        return {
+            kind: "confidence",
+            message: `agentRules: scope "workspace" requires a workspace or repository path but none was resolved — skipping "${entry.name}" for agent "${agentId}"`,
+        };
+    }
+    const agent = AGENT_REGISTRY_BY_ID[agentId];
+    return {
+        agentId,
+        confidence: agent?.provenance.agentRules ?? "provisional",
+        target: resolvePlaceholders(support.path[platform], entry.name, home, repo, workspace),
+    };
+}
+export async function compileAgentRuleActions(entry, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo, workspace) {
     const actions = [];
     const warnings = [];
     const platform = getPlatformKey();
@@ -12,38 +68,45 @@ export async function compileAgentRuleActions(entry, sourceDir, resolvedSourceDi
         return { actions, warnings };
     }
     for (const agentId of targetAgents) {
-        const agent = AGENT_REGISTRY_BY_ID[agentId];
-        const support = agent?.agentRulesSupport;
-        if (!support || support.status === "unsupported") {
-            warnings.push({
-                kind: "confidence",
-                message: `agentRules: agent "${agentId}" uses ${support?.schemaLabel ?? "an unsupported instruction schema"} and ${support?.status === "unsupported" ? support.reason : "does not expose a supported rules adapter"} — skipping "${entry.name}"`,
-            });
-            continue;
+        const result = resolveAgentTarget(agentId, entry, home, repo, platform, workspace, targetAgents);
+        if ("kind" in result) {
+            warnings.push(result);
         }
-        if (support.status === "planned") {
-            warnings.push({
-                kind: "confidence",
-                message: `agentRules: agent "${agentId}" rules support is planned via ${support.plannedSurface} — skipping "${entry.name}" until that surface is implemented`,
-            });
-            continue;
+        else {
+            supportedTargets.push(result);
         }
-        supportedTargets.push({
-            agentId,
-            confidence: agent.provenance.agentRules ?? "provisional",
-            target: resolvePlaceholders(support.path[platform], entry.name, home, repo),
-        });
     }
     if (supportedTargets.length === 0) {
         return { actions, warnings };
     }
+    // Deduplicate: when a shared-via rider's primary is also in supportedTargets,
+    // skip the rider — the primary agent writes the shared surface. As a fallback,
+    // also dedup by resolved path so no target file is written twice.
+    const seenTargetPaths = new Set();
+    const dedupedTargets = [];
+    for (const t of supportedTargets) {
+        const sup = resolveRulesSupport(t.agentId, entry.scope);
+        if (sup?.status === "supported" &&
+            sup.surfaceKind?.kind === "shared-via" &&
+            supportedTargets.some((o) => o.agentId ===
+                sup.surfaceKind.via &&
+                o.target === t.target)) {
+            // Primary agent is present and writes the same target — skip rider.
+            continue;
+        }
+        if (!seenTargetPaths.has(t.target)) {
+            seenTargetPaths.add(t.target);
+            dedupedTargets.push(t);
+        }
+    }
     // Validate the shared source file only when at least one target uses the
-    // current global-Markdown adapter surface.
+    // current rules adapter surface.
     const source = path.resolve(sourceDir, entry.path);
     await validateSourcePath(source, entry.path, resolvedSourceDir, realRoot);
     await validateSourceFile(source, entry.path);
-    for (const target of supportedTargets) {
+    for (const target of dedupedTargets) {
         validateAgentRuleMarkdownPath(entry.path, target.agentId);
+        await validateInstructionFileRequirements(source, entry.path, target.agentId);
         actions.push({
             kind: "file-write",
             skill: entry.name,
@@ -55,19 +118,27 @@ export async function compileAgentRuleActions(entry, sourceDir, resolvedSourceDi
     }
     return { actions, warnings };
 }
-export function compileAgentRuleReverts(entry, agentFilter, home, repo) {
+export function compileAgentRuleReverts(entry, agentFilter, home, repo, workspace) {
     const actions = [];
     const platform = getPlatformKey();
+    const seenRevertTargets = new Set();
     for (const agentId of entry.agents) {
         if (agentFilter && !agentFilter.includes(agentId))
             continue;
-        const agent = AGENT_REGISTRY_BY_ID[agentId];
-        const support = agent?.agentRulesSupport;
+        const support = resolveRulesSupport(agentId, entry.scope);
         if (!support ||
             support.status === "unsupported" ||
-            support.status === "planned")
+            support.status === "planned") {
+            continue;
+        }
+        if (entry.scope === "repo" && !repo)
+            continue;
+        if (entry.scope === "workspace" && !workspace && !repo)
+            continue;
+        const target = resolvePlaceholders(support.path[platform], entry.name, home, repo, workspace);
+        if (seenRevertTargets.has(target))
             continue;
-        const target = resolvePlaceholders(support.path[platform], entry.name, home, repo);
+        seenRevertTargets.add(target);
         actions.push({
             kind: "file-write",
             skill: entry.name,

package/dist/core/deploy.d.ts

@@ -1,6 +1,6 @@
 import type { AgentId, DeployAction, Manifest, PlannedChange, PlanWarning, SkillDirDeployAction } from "../types.ts";
 import { type RegistryPersistence } from "./ownership.ts";
-export declare function planDeploy(manifest: Manifest, sourceDir: string, detectedAgents: AgentId[], home: string): Promise<{
+export declare function planDeploy(manifest: Manifest, sourceDir: string, detectedAgents: AgentId[], home: string, repo?: string, workspace?: string): Promise<{
     actions: DeployAction[];
     warnings: PlanWarning[];
 }>;

package/dist/core/deploy.js

@@ -1,7 +1,7 @@
 import { constants } from "node:fs";
 import { access, copyFile, cp, lstat, mkdir, readFile, realpath, rename, rm, symlink, unlink, writeFile, } from "node:fs/promises";
 import path from "node:path";
-import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
+import { AGENT_REGISTRY, AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { UserError } from "../errors.js";
 import { logger } from "../logger.js";
 import { compileAdapterActions } from "./adapters/index.js";
@@ -80,26 +80,118 @@ function detectCollisions(actions) {
     }
     return warnings;
 }
-function detectAmbiguities(detectedAgents, manifest) {
-    const warnings = [];
-    if (!(detectedAgents.includes("gemini-cli") &&
-        detectedAgents.includes("antigravity"))) {
-        return warnings;
+/**
+ * Finds all (primary, rider) pairs among detected agents where the rider has
+ * at least one surface annotated as `shared-via` the primary and the primary
+ * is also detected. Used to drive ambiguity warnings without hardcoding agent
+ * IDs.
+ */
+function findSharedSurfacePairs(detectedAgents) {
+    const pairs = [];
+    for (const agent of AGENT_REGISTRY) {
+        if (!detectedAgents.includes(agent.id))
+            continue;
+        const surfaces = [
+            agent.agentRulesSupport,
+            agent.agentRulesRepoSupport,
+            agent.agentRulesWorkspaceSupport,
+            agent.mcpSupport,
+            agent.agentDefinitionsSupport,
+        ];
+        for (const surface of surfaces) {
+            if (surface?.status === "supported" &&
+                surface.surfaceKind?.kind === "shared-via") {
+                const via = surface.surfaceKind.via;
+                if (detectedAgents.includes(via) &&
+                    !pairs.some((p) => p.primary === via && p.rider === agent.id)) {
+                    pairs.push({ primary: via, rider: agent.id });
+                }
+            }
+        }
     }
-    const bothAgents = (agents) => agents.includes("gemini-cli") && agents.includes("antigravity");
+    return pairs;
+}
+function resolveAgentRulesSupportForScope(agentId, scope) {
+    const agent = AGENT_REGISTRY_BY_ID[agentId];
+    if (scope === "repo")
+        return agent?.agentRulesRepoSupport ?? agent?.agentRulesSupport;
+    if (scope === "workspace") {
+        return (agent?.agentRulesWorkspaceSupport ??
+            agent?.agentRulesRepoSupport ??
+            agent?.agentRulesSupport);
+    }
+    return agent?.agentRulesSupport;
+}
+function checkPairAgentRuleAmbiguities(manifest, primary, rider) {
+    const warnings = [];
     for (const entry of manifest.agentRules ?? []) {
-        if (bothAgents(entry.agents)) {
+        if (!(entry.agents.includes(primary) && entry.agents.includes(rider)))
+            continue;
+        const primarySupport = resolveAgentRulesSupportForScope(primary, entry.scope);
+        const riderSupport = resolveAgentRulesSupportForScope(rider, entry.scope);
+        if (primarySupport?.status === "supported" &&
+            riderSupport?.status === "supported" &&
+            JSON.stringify(primarySupport.path) === JSON.stringify(riderSupport.path)) {
             warnings.push({
                 kind: "ambiguity",
-                message: `Both "gemini-cli" and "antigravity" are listed in agentRules entry "${entry.name}". They write to distinct surfaces ("gemini-cli" → ~/.gemini/GEMINI.md, "antigravity" → {repo}/.agents/rules/${entry.name}.md) from the same source file — verify that deploying to both produces the intended behavior on each agent.`,
+                message: `Both "${primary}" and "${rider}" are listed in agentRules entry "${entry.name}". Both target the same surface — listing both is redundant but harmless; deduplication ensures only one write action is emitted.`,
             });
         }
     }
+    return warnings;
+}
+function checkPairMcpAmbiguities(manifest, primary, rider) {
+    const warnings = [];
+    const primaryMcp = AGENT_REGISTRY_BY_ID[primary]?.mcpSupport;
+    const riderMcp = AGENT_REGISTRY_BY_ID[rider]?.mcpSupport;
+    if (primaryMcp?.status !== "supported" || riderMcp?.status !== "supported")
+        return warnings;
     for (const entry of manifest.mcpServers ?? []) {
-        if (bothAgents(entry.agents)) {
+        if (!(entry.agents.includes(primary) && entry.agents.includes(rider)))
+            continue;
+        warnings.push({
+            kind: "ambiguity",
+            message: `Both "${primary}" and "${rider}" are listed in mcpServers entry "${entry.name}". "${primary}" writes to a shared MCP surface — verify that deploying to both does not produce conflicting MCP server behavior.`,
+        });
+    }
+    return warnings;
+}
+function checkPairAgentDefinitionAmbiguities(manifest, primary, rider) {
+    const warnings = [];
+    for (const entry of manifest.agentDefinitions ?? []) {
+        if (!(entry.agents.includes(primary) && entry.agents.includes(rider)))
+            continue;
+        warnings.push({
+            kind: "ambiguity",
+            message: `Both "${primary}" and "${rider}" are listed in agentDefinitions entry "${entry.name}". They write to distinct surfaces — verify that this behavioral divergence is intended.`,
+        });
+    }
+    return warnings;
+}
+function detectAmbiguities(detectedAgents, manifest) {
+    const pairs = findSharedSurfacePairs(detectedAgents);
+    if (pairs.length === 0)
+        return [];
+    const warnings = [];
+    for (const { primary, rider } of pairs) {
+        warnings.push(...checkPairAgentRuleAmbiguities(manifest, primary, rider));
+        warnings.push(...checkPairMcpAmbiguities(manifest, primary, rider));
+        warnings.push(...checkPairAgentDefinitionAmbiguities(manifest, primary, rider));
+    }
+    return warnings;
+}
+function checkAntigravityPathCollisions(manifest) {
+    const warnings = [];
+    const defNames = new Set((manifest.agentDefinitions ?? [])
+        .filter((e) => e.agents.includes("antigravity"))
+        .map((e) => e.name));
+    for (const entry of manifest.mcpServers ?? []) {
+        if (!entry.agents.includes("antigravity"))
+            continue;
+        if (defNames.has(entry.name)) {
             warnings.push({
-                kind: "ambiguity",
-                message: `Both "gemini-cli" and "antigravity" are listed in mcpServers entry "${entry.name}". "gemini-cli" writes to ~/.gemini/settings.json as a shared surface — verify that deploying to both does not produce conflicting MCP server behavior.`,
+                kind: "collision",
+                message: `agentDefinitions entry "${entry.name}" and mcpServers entry "${entry.name}" for agent "antigravity" both resolve to {repo}/.agents/rules/${entry.name}.md — one will silently overwrite the other; use different names or remove one entry`,
             });
         }
     }
@@ -134,7 +226,7 @@ async function planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realR
     }
     return actions;
 }
-async function planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home) {
+async function planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo, workspace) {
     const actions = [];
     for (const fileEntry of manifest.files ?? []) {
         const targetAgents = fileEntry.agents.filter((agentId) => detectedAgents.includes(agentId));
@@ -152,14 +244,14 @@ async function planFileWriteActions(manifest, sourceDir, resolvedSourceDir, real
                 skill: fileEntry.name,
                 agent: agentId,
                 source,
-                target: resolveTargetTemplate(fileEntry.target, home),
+                target: resolveTargetTemplate(fileEntry.target, home, repo, workspace),
                 confidence: agent.provenance.skills,
             });
         }
     }
     return actions;
 }
-function planConfigPatchActions(manifest, detectedAgents, home) {
+function planConfigPatchActions(manifest, detectedAgents, home, repo, workspace) {
     const actions = [];
     for (const configEntry of manifest.configs ?? []) {
         for (const agentId of configEntry.agents) {
@@ -172,7 +264,7 @@ function planConfigPatchActions(manifest, detectedAgents, home) {
                 kind: "config-patch",
                 skill: configEntry.name,
                 agent: agentId,
-                target: resolveTargetTemplate(configEntry.target, home),
+                target: resolveTargetTemplate(configEntry.target, home, repo, workspace),
                 patch: configEntry.patch,
                 confidence: agent.provenance.skills,
             });
@@ -180,7 +272,7 @@ function planConfigPatchActions(manifest, detectedAgents, home) {
     }
     return actions;
 }
-export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
+export async function planDeploy(manifest, sourceDir, detectedAgents, home, repo, workspace) {
     const resolvedSourceDir = path.resolve(sourceDir);
     let realRoot;
     try {
@@ -189,15 +281,17 @@ export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
     catch {
         realRoot = resolvedSourceDir;
     }
+    const repoDir = repo ?? realRoot;
     const actions = [
         ...(await planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home)),
-        ...(await planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home)),
-        ...planConfigPatchActions(manifest, detectedAgents, home),
+        ...(await planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repoDir, workspace)),
+        ...planConfigPatchActions(manifest, detectedAgents, home, repoDir, workspace),
     ];
-    const adapterResult = await compileAdapterActions(manifest.mcpServers, manifest.agentRules, manifest.permissions ?? [], sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, undefined, manifest.agentDefinitions ?? []);
+    const adapterResult = await compileAdapterActions(manifest.mcpServers, manifest.agentRules, manifest.permissions ?? [], sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repoDir, manifest.agentDefinitions ?? [], workspace);
     actions.push(...adapterResult.actions);
     const warnings = [
         ...detectAmbiguities(detectedAgents, manifest),
+        ...checkAntigravityPathCollisions(manifest),
         ...detectCollisions(actions),
         ...adapterResult.warnings,
     ];
@@ -208,44 +302,32 @@ export async function executeDeploy(actions, dryRun, verbose, home, deps = {}) {
     const failed = [];
     const planned = [];
     for (const action of actions) {
-        switch (action.kind) {
-            case "skill-dir": {
-                const result = await deploySkillDir(action, dryRun, verbose, home, planned, deps);
-                if (result.error === null) {
-                    succeeded++;
-                }
-                else {
-                    failed.push({ action, error: result.error });
-                }
-                break;
-            }
-            case "file-write": {
-                const result = await deployFileWrite(action, dryRun, verbose, home, planned, deps);
-                if (result.error === null) {
-                    succeeded++;
-                }
-                else {
-                    failed.push({ action, error: result.error });
-                }
-                break;
-            }
-            case "config-patch": {
-                const result = await deployConfigPatch(action, dryRun, verbose, home, planned, deps);
-                if (result.error === null) {
-                    succeeded++;
-                }
-                else {
-                    failed.push({ action, error: result.error });
-                }
-                break;
-            }
-            default: {
-                throw new Error(`Unhandled deploy action kind: ${action}`);
-            }
+        const result = await dispatchDeployAction(action, dryRun, verbose, home, planned, deps);
+        if (result.error === null) {
+            succeeded++;
+        }
+        else {
+            failed.push({ action, error: result.error });
         }
     }
     return { succeeded, failed, planned };
 }
+async function dispatchDeployAction(action, dryRun, verbose, home, planned, deps) {
+    switch (action.kind) {
+        case "skill-dir":
+            return deploySkillDir(action, dryRun, verbose, home, planned, deps);
+        case "file-write":
+            return deployFileWrite(action, dryRun, verbose, home, planned, deps);
+        case "config-patch":
+            return deployConfigPatch(action, dryRun, verbose, home, planned, deps);
+        case "toml-patch":
+            return deployTomlPatch(action, dryRun, verbose, home, planned, deps);
+        case "frontmatter-emit":
+            return deployFrontmatterEmit(action, dryRun, verbose, home, planned, deps);
+        default:
+            throw new Error(`Unhandled deploy action kind: ${action.kind}`);
+    }
+}
 const defaultSkillDirOps = {
     async createTarget(action) {
         if (action.method === "symlink") {
@@ -483,6 +565,76 @@ async function deployConfigPatch(action, dryRun, verbose, home, planned, deps) {
         return { error: msg };
     }
 }
+async function deployTomlPatch(action, dryRun, verbose, home, planned, deps) {
+    const label = `${action.skill} -> ${action.agent}`;
+    if (dryRun) {
+        planned.push({
+            verb: "patch-toml",
+            kind: "toml-patch",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+            patch: action.config,
+        });
+        return { error: null };
+    }
+    try {
+        const { previousValue } = await (deps.registry
+            ? Promise.resolve({ previousValue: null })
+            : (await import("./adapters/toml.js")).applyTomlMcpPatch(action.target, action.skill, action.config));
+        // Note: To truly support custom deps here we'd need to refactor toml adapter to accept deps.
+        // For now we assume standard adapter for TOML.
+        await registerDeployment(home, action.target, {
+            kind: "config-patch",
+            patch: action.config,
+            undoPatch: { mcpServers: { [action.skill]: previousValue } },
+            skill: action.skill,
+            agent: action.agent,
+        }, deps.registry);
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`patch-toml: ${action.target}`);
+        }
+        return { error: null };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+}
+async function deployFrontmatterEmit(action, dryRun, verbose, home, planned, deps) {
+    const label = `${action.skill} -> ${action.agent}`;
+    if (dryRun) {
+        planned.push({
+            verb: "emit-frontmatter",
+            kind: "frontmatter-emit",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+            frontmatter: action.frontmatter,
+        });
+        return { error: null };
+    }
+    try {
+        await (await import("./adapters/frontmatter.js")).writeFrontmatterFile(action.target, action.frontmatter, { preserveBody: true });
+        await registerDeployment(home, action.target, {
+            kind: "frontmatter-emit",
+            skill: action.skill,
+            agent: action.agent,
+        }, deps.registry);
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`emit-frontmatter: ${action.target}`);
+        }
+        return { error: null };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+}
 async function validateSkillContract(source, skillPath) {
     let stat;
     try {