@kuznai/inception-engine 0.12.0 → 0.13.0

package/README.md

@@ -48,8 +48,8 @@ Managed skills overwrite their previous version. If a target exists but was not
 | Skills (SKILL.md) | All agents via manifest and CLI | All agents |
 | File write | All agents via manifest and CLI | All agents |
 | Config patch (JSON merge) | All agents via manifest and CLI | All agents |
-| MCP Servers | claude-code, gemini-cli; other agents are warned and skipped | claude-code, gemini-cli |
-| Global Rules Files | claude-code, codex, gemini-cli, opencode; github-copilot reads CLAUDE.md natively (deploy via claude-code); other agents are warned and skipped | claude-code, codex, gemini-cli, opencode |
+| MCP Servers | claude-code, gemini-cli, codex, antigravity, opencode; github-copilot repo-scoped surfaces are warned and skipped | claude-code, gemini-cli, codex, antigravity, opencode |
+| Global/Repo Rules Files | All agents (antigravity uses repo-local `.agents/rules/`); github-copilot reads CLAUDE.md natively (deploy via claude-code) | All agents |
 | `init` manifest generation | Scans `SKILL.md` directories and writes starter `skills` entries | N/A |
 
 Features that depend on agent-specific config surfaces are intentionally conservative: if a target path or schema is not implemented with enough confidence, inception-engine warns and skips it rather than guessing.
@@ -130,7 +130,12 @@ Each **mcpServer** entry registers an MCP server into the agent's config file by
 - **agents** - Array of agent IDs to register this server with
 - **config** - Raw server descriptor object. For the currently supported JSON-backed adapters, inception-engine requires at least one non-empty `command` or `url` field, validates `args` as an array of strings when present, and validates `env` as a string-to-string object when present. Additional keys are passed through verbatim.
 
-MCP server registration is currently supported for `claude-code` (`~/.claude.json`) and `gemini-cli` (`~/.gemini/settings.json`). Other agents emit a schema-aware warning and are skipped when their support would require a non-JSON adapter, such as Codex `config.toml`, Antigravity frontmatter in repo-scoped rules files, OpenCode `opencode.json`, or GitHub Copilot repo-scoped MCP surfaces. Revert removes the registered server entry from the config file.
+MCP server registration is supported for all agents except GitHub Copilot. Inception-engine automatically uses the correct adapter for each agent's configuration schema:
+- **JSON (Merge Patch)**: `claude-code` (`~/.claude.json`), `gemini-cli` (`~/.gemini/settings.json`), and `opencode` (`~/.config/opencode/opencode.json` using the custom `"mcp"` key).
+- **TOML (Patch)**: `codex` (`~/.codex/config.toml`).
+- **Markdown Frontmatter (Emit)**: `antigravity` (repo-local `.agents/rules/{name}.md` files).
+
+Revert removes the registered server entry from the respective configuration file. GitHub Copilot, which uses repo-scoped MCP surfaces not yet implemented by inception-engine, continues to emit a schema-aware warning and is skipped.
 
 Each **agentRules** entry deploys a Markdown instruction file to an agent's supported global rules file location:
 
@@ -138,7 +143,7 @@ Each **agentRules** entry deploys a Markdown instruction file to an agent's supp
 - **path** - Relative path to the source Markdown file within the repo; supported global rules adapters require a `.md` or `.markdown` source path
 - **agents** - Array of agent IDs to deploy this file to
 
-Global rules-file deployment is currently supported for `claude-code` (`~/.claude/CLAUDE.md`), `codex` (`~/.codex/AGENTS.md`), `gemini-cli` (`~/.gemini/GEMINI.md`), and `opencode` (`~/.config/opencode/AGENTS.md`). For `github-copilot`, no separate deployment is needed because Copilot reads `CLAUDE.md` natively — target it via the `claude-code` agentRules entry and it reaches Copilot automatically. Other agents emit schema-aware warnings and are skipped when their instruction surfaces are repo-scoped, frontmatter-driven, or otherwise not implemented as a single global Markdown file. Revert removes the deployed rules file.
+Instruction rule deployment is supported for all agents. For most agents, this targets a single global rules file (e.g., `~/.claude/CLAUDE.md` for `claude-code`, `~/.codex/AGENTS.md` for `codex`, `~/.gemini/GEMINI.md` for `gemini-cli`, and `~/.config/opencode/AGENTS.md` for `opencode`). For `antigravity`, inception-engine deploys to repo-local instruction surfaces at `{repo}/.agents/rules/{name}.md`. For `github-copilot`, no separate deployment is needed because Copilot reads `CLAUDE.md` natively — target it via the `claude-code` agentRules entry and it reaches Copilot automatically. Revert removes the deployed rules file.
 
 ## Creating Skills
 

package/dist/config/agents.js

@@ -54,9 +54,12 @@ export const AGENT_REGISTRY = [
             agentRules: "documented",
         },
         mcpSupport: {
-            status: "unsupported",
-            schemaLabel: "config.toml MCP schema",
-            reason: "Codex stores MCP servers in config.toml, so JSON merge-patch deployment is not sufficient yet",
+            status: "supported",
+            schemaLabel: "TOML mcpServers config",
+            path: {
+                posix: ["{home}", ".codex", "config.toml"],
+                windows: ["{home}", ".codex", "config.toml"],
+            },
         },
         agentRulesSupport: {
             status: "supported",
@@ -121,14 +124,20 @@ export const AGENT_REGISTRY = [
             detectBinary: "provisional",
         },
         mcpSupport: {
-            status: "unsupported",
-            schemaLabel: "frontmatter-driven MCP rules",
-            reason: "Antigravity MCP support depends on frontmatter inside repo-scoped .agents/rules files, which this release does not translate or validate yet",
+            status: "supported",
+            schemaLabel: "repo-local frontmatter-emit MCP rules",
+            path: {
+                posix: ["{repo}", ".agents", "rules", "{name}.md"],
+                windows: ["{repo}", ".agents", "rules", "{name}.md"],
+            },
         },
         agentRulesSupport: {
-            status: "unsupported",
-            schemaLabel: "repo-scoped rules files",
-            reason: "Antigravity instructions live in repo-scoped .agents/rules files rather than one global Markdown target",
+            status: "supported",
+            schemaLabel: "repo-local Markdown rules file",
+            path: {
+                posix: ["{repo}", ".agents", "rules", "{name}.md"],
+                windows: ["{repo}", ".agents", "rules", "{name}.md"],
+            },
         },
     },
     {
@@ -150,9 +159,13 @@ export const AGENT_REGISTRY = [
             agentRules: "documented",
         },
         mcpSupport: {
-            status: "unsupported",
-            schemaLabel: "opencode.json MCP schema",
-            reason: "OpenCode keeps MCP config in opencode.json under its own shape, so plain JSON merge-patch support is not implemented here",
+            status: "supported",
+            schemaLabel: "opencode.json MCP config",
+            path: {
+                posix: ["{xdg_config}", "opencode", "opencode.json"],
+                windows: ["{appdata}", "opencode", "opencode.json"],
+            },
+            mcpPatchKey: "mcp",
         },
         agentRulesSupport: {
             status: "supported",

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

@@ -0,0 +1,26 @@
+/**
+ * Serializes a flat (one-level) object to a YAML block suitable for use inside
+ * `---` frontmatter delimiters.
+ */
+export declare function serializeFrontmatter(data: Record<string, unknown>): string;
+/**
+ * Builds the full content of a frontmatter-bearing Markdown file.
+ * If `body` is provided it is appended after the closing delimiter.
+ */
+export declare function buildFrontmatterDocument(frontmatter: Record<string, unknown>, body?: string): string;
+/**
+ * Reads an existing `.md` file and parses its frontmatter (using the
+ * `front-matter` package). Returns the parsed attributes and raw body.
+ * Returns `{ attributes: {}, body: "" }` if the file does not exist.
+ */
+export declare function readFrontmatterFile(filePath: string): Promise<{
+    attributes: Record<string, unknown>;
+    body: string;
+}>;
+/**
+ * Atomically writes a Markdown file with the given frontmatter and optional
+ * body. Preserves any existing body content when `preserveBody` is true.
+ */
+export declare function writeFrontmatterFile(filePath: string, frontmatter: Record<string, unknown>, options?: {
+    preserveBody?: boolean;
+}): Promise<void>;

package/dist/core/adapters/frontmatter.js

@@ -0,0 +1,120 @@
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+const _require = createRequire(import.meta.url);
+// front-matter is a CommonJS module whose export is the callable parse function.
+const parseFrontmatter = _require("front-matter");
+// ---------------------------------------------------------------------------
+// Hand-rolled flat-YAML serializer
+// Handles the shapes found in MCP server descriptors: strings, numbers,
+// booleans, string arrays, and one-level nested objects (e.g. "env").
+// ---------------------------------------------------------------------------
+function serializeScalar(value) {
+    if (typeof value === "string") {
+        const needsQuotes = /[:#[\]{},|>&*!'"@`]|^\s|\s$/.test(value);
+        return needsQuotes
+            ? `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`
+            : value;
+    }
+    return String(value);
+}
+function serializeArray(key, arr, pad) {
+    if (arr.length === 0)
+        return `${pad}${key}: []`;
+    const items = arr.map((item) => {
+        const scalar = typeof item === "string" ||
+            typeof item === "number" ||
+            typeof item === "boolean"
+            ? serializeScalar(item)
+            : JSON.stringify(item);
+        return `${pad}  - ${scalar}`;
+    });
+    return [`${pad}${key}:`, ...items].join("\n");
+}
+function serializeObject(key, obj, pad) {
+    const inner = serializeFrontmatterAtDepth(obj, `${pad}  `);
+    return inner ? `${pad}${key}:\n${inner}` : `${pad}${key}: {}`;
+}
+function serializeFrontmatterAtDepth(data, pad) {
+    const lines = [];
+    for (const [key, value] of Object.entries(data)) {
+        if (value === null || value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            lines.push(serializeArray(key, value, pad));
+        }
+        else if (typeof value === "object") {
+            lines.push(serializeObject(key, value, pad));
+        }
+        else {
+            lines.push(`${pad}${key}: ${serializeScalar(value)}`);
+        }
+    }
+    return lines.join("\n");
+}
+/**
+ * Serializes a flat (one-level) object to a YAML block suitable for use inside
+ * `---` frontmatter delimiters.
+ */
+export function serializeFrontmatter(data) {
+    return serializeFrontmatterAtDepth(data, "");
+}
+/**
+ * Builds the full content of a frontmatter-bearing Markdown file.
+ * If `body` is provided it is appended after the closing delimiter.
+ */
+export function buildFrontmatterDocument(frontmatter, body = "") {
+    const serialized = serializeFrontmatter(frontmatter);
+    return `---\n${serialized}\n---\n${body}`;
+}
+function createAtomicTempPath(targetPath) {
+    return `${targetPath}.inception-tmp-${process.pid}-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2)}`;
+}
+/**
+ * Reads an existing `.md` file and parses its frontmatter (using the
+ * `front-matter` package). Returns the parsed attributes and raw body.
+ * Returns `{ attributes: {}, body: "" }` if the file does not exist.
+ */
+export async function readFrontmatterFile(filePath) {
+    let raw;
+    try {
+        raw = await readFile(filePath, "utf-8");
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return { attributes: {}, body: "" };
+        throw err;
+    }
+    const parsed = parseFrontmatter(raw);
+    return { attributes: parsed.attributes, body: parsed.body };
+}
+/**
+ * Atomically writes a Markdown file with the given frontmatter and optional
+ * body. Preserves any existing body content when `preserveBody` is true.
+ */
+export async function writeFrontmatterFile(filePath, frontmatter, options = {}) {
+    let body = "";
+    if (options.preserveBody) {
+        const existing = await readFrontmatterFile(filePath);
+        body = existing.body;
+    }
+    const content = buildFrontmatterDocument(frontmatter, body);
+    const tempPath = createAtomicTempPath(filePath);
+    try {
+        await mkdir(path.dirname(filePath), { recursive: true });
+        await writeFile(tempPath, content, "utf-8");
+        await rename(tempPath, filePath);
+    }
+    catch (err) {
+        try {
+            await rm(tempPath, { force: true });
+        }
+        catch {
+            /* best-effort cleanup */
+        }
+        throw err;
+    }
+}

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

@@ -1,11 +1,11 @@
 import type { AgentRuleEntry, McpServerEntry } from "../../schemas/manifest.ts";
-import type { AgentId, ConfigPatchDeployAction, FileWriteDeployAction, PlanWarning } from "../../types.ts";
+import type { AgentId, ConfigPatchDeployAction, FileWriteDeployAction, FrontmatterEmitDeployAction, PlanWarning, TomlPatchDeployAction } from "../../types.ts";
 import { compileMcpServerReverts } from "./mcp.ts";
 import { compileAgentRuleReverts } from "./rules.ts";
 export { compileAgentRuleReverts, compileMcpServerReverts };
-export type AdapterAction = ConfigPatchDeployAction | FileWriteDeployAction;
+export type AdapterAction = ConfigPatchDeployAction | FileWriteDeployAction | TomlPatchDeployAction | FrontmatterEmitDeployAction;
 export interface AdapterResult {
     actions: AdapterAction[];
     warnings: PlanWarning[];
 }
-export declare function compileAdapterActions(mcpServers: McpServerEntry[], agentRules: AgentRuleEntry[], sourceDir: string, resolvedSourceDir: string, realRoot: string, detectedAgents: AgentId[], home: string): Promise<AdapterResult>;
+export declare function compileAdapterActions(mcpServers: McpServerEntry[], agentRules: AgentRuleEntry[], sourceDir: string, resolvedSourceDir: string, realRoot: string, detectedAgents: AgentId[], home: string, repo?: string): Promise<AdapterResult>;

package/dist/core/adapters/index.js

@@ -1,16 +1,16 @@
 import { compileMcpServerActions, compileMcpServerReverts } from "./mcp.js";
 import { compileAgentRuleActions, compileAgentRuleReverts } from "./rules.js";
 export { compileAgentRuleReverts, compileMcpServerReverts };
-export async function compileAdapterActions(mcpServers, agentRules, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home) {
+export async function compileAdapterActions(mcpServers, agentRules, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo) {
     const actions = [];
     const warnings = [];
     for (const entry of mcpServers) {
-        const r = compileMcpServerActions(entry, detectedAgents, home);
+        const r = compileMcpServerActions(entry, detectedAgents, home, repo);
         actions.push(...r.actions);
         warnings.push(...r.warnings);
     }
     for (const entry of agentRules) {
-        const r = await compileAgentRuleActions(entry, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home);
+        const r = await compileAgentRuleActions(entry, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo);
         actions.push(...r.actions);
         warnings.push(...r.warnings);
     }

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

@@ -1,8 +1,8 @@
 import type { McpServerEntry } from "../../schemas/manifest.ts";
-import type { AgentId, ConfigPatchDeployAction, ConfigPatchRevertAction, PlanWarning } from "../../types.ts";
+import type { AgentId, ConfigPatchDeployAction, ConfigPatchRevertAction, FrontmatterEmitDeployAction, FrontmatterEmitRevertAction, PlanWarning, TomlPatchDeployAction, TomlPatchRevertAction } from "../../types.ts";
 export interface McpAdapterResult {
-    actions: ConfigPatchDeployAction[];
+    actions: Array<ConfigPatchDeployAction | TomlPatchDeployAction | FrontmatterEmitDeployAction>;
     warnings: PlanWarning[];
 }
-export declare function compileMcpServerActions(entry: McpServerEntry, detectedAgents: AgentId[], home: string): McpAdapterResult;
-export declare function compileMcpServerReverts(entry: McpServerEntry, agentFilter: AgentId[] | null, home: string): ConfigPatchRevertAction[];
+export declare function compileMcpServerActions(entry: McpServerEntry, detectedAgents: AgentId[], home: string, repo?: string): McpAdapterResult;
+export declare function compileMcpServerReverts(entry: McpServerEntry, agentFilter: AgentId[] | null, home: string, repo?: string): Array<ConfigPatchRevertAction | TomlPatchRevertAction | FrontmatterEmitRevertAction>;

package/dist/core/adapters/mcp.js

@@ -2,7 +2,51 @@ import path from "node:path";
 import { AGENT_REGISTRY_BY_ID } from "../../config/agents.js";
 import { getPlatformKey, resolvePlaceholders } from "../resolve.js";
 import { validateMcpServerConfigShape } from "../validation.js";
-export function compileMcpServerActions(entry, detectedAgents, home) {
+/**
+ * Determines whether a resolved config path targets a TOML file.
+ */
+function isTomlTarget(targetPath) {
+    return path.extname(targetPath).toLowerCase() === ".toml";
+}
+/**
+ * Determines whether a resolved config path targets a Markdown file
+ * (indicates a frontmatter-emit surface, e.g. Antigravity's .agents/rules/).
+ */
+function isMarkdownTarget(targetPath) {
+    const ext = path.extname(targetPath).toLowerCase();
+    return ext === ".md" || ext === ".markdown";
+}
+function buildMcpDeployAction(entry, agentId, resolvedTarget, confidence, mcpPatchKey) {
+    if (isMarkdownTarget(resolvedTarget)) {
+        return {
+            kind: "frontmatter-emit",
+            skill: entry.name,
+            agent: agentId,
+            target: resolvedTarget,
+            frontmatter: { "mcp-servers": { [entry.name]: entry.config } },
+            confidence,
+        };
+    }
+    if (isTomlTarget(resolvedTarget)) {
+        return {
+            kind: "toml-patch",
+            skill: entry.name,
+            agent: agentId,
+            target: resolvedTarget,
+            config: entry.config,
+            confidence,
+        };
+    }
+    return {
+        kind: "config-patch",
+        skill: entry.name,
+        agent: agentId,
+        target: resolvedTarget,
+        patch: { [mcpPatchKey]: { [entry.name]: entry.config } },
+        confidence,
+    };
+}
+export function compileMcpServerActions(entry, detectedAgents, home, repo) {
     const actions = [];
     const warnings = [];
     const platform = getPlatformKey();
@@ -14,26 +58,20 @@ export function compileMcpServerActions(entry, detectedAgents, home) {
         if (!support || support.status === "unsupported") {
             warnings.push({
                 kind: "confidence",
-                message: `mcpServers: agent "${agentId}" uses ${support?.schemaLabel ?? "an unsupported MCP schema"} and ${support?.reason ?? "does not expose a supported MCP adapter"} — skipping "${entry.name}"`,
+                message: `mcpServers: agent "${agentId}" uses ${support?.schemaLabel ?? "an unsupported MCP schema"} and ${support?.status === "unsupported" ? support.reason : "does not expose a supported MCP adapter"} — skipping "${entry.name}"`,
             });
             continue;
         }
         validateMcpServerConfigShape(entry.config, entry.name, agentId);
-        const target = resolvePlaceholders(support.path[platform], "", home);
-        // Ensure no stray empty segments collapse the path unexpectedly
-        const resolvedTarget = path.resolve(target);
-        actions.push({
-            kind: "config-patch",
-            skill: entry.name,
-            agent: agentId,
-            target: resolvedTarget,
-            patch: { mcpServers: { [entry.name]: entry.config } },
-            confidence: agent.provenance.mcpConfig ?? "provisional",
-        });
+        const rawTarget = resolvePlaceholders(support.path[platform], entry.name, home, repo);
+        const resolvedTarget = path.resolve(rawTarget);
+        const confidence = agent.provenance.mcpConfig ?? "provisional";
+        const mcpPatchKey = support.mcpPatchKey ?? "mcpServers";
+        actions.push(buildMcpDeployAction(entry, agentId, resolvedTarget, confidence, mcpPatchKey));
     }
     return { actions, warnings };
 }
-export function compileMcpServerReverts(entry, agentFilter, home) {
+export function compileMcpServerReverts(entry, agentFilter, home, repo) {
     const actions = [];
     const platform = getPlatformKey();
     for (const agentId of entry.agents) {
@@ -43,13 +81,32 @@ export function compileMcpServerReverts(entry, agentFilter, home) {
         const support = agent?.mcpSupport;
         if (!support || support.status === "unsupported")
             continue;
-        const target = path.resolve(resolvePlaceholders(support.path[platform], "", home));
-        actions.push({
-            kind: "config-patch",
-            skill: entry.name,
-            agent: agentId,
-            target,
-        });
+        const rawTarget = resolvePlaceholders(support.path[platform], entry.name, home, repo);
+        const target = path.resolve(rawTarget);
+        if (isMarkdownTarget(target)) {
+            actions.push({
+                kind: "frontmatter-emit",
+                skill: entry.name,
+                agent: agentId,
+                target,
+            });
+        }
+        else if (isTomlTarget(target)) {
+            actions.push({
+                kind: "toml-patch",
+                skill: entry.name,
+                agent: agentId,
+                target,
+            });
+        }
+        else {
+            actions.push({
+                kind: "config-patch",
+                skill: entry.name,
+                agent: agentId,
+                target,
+            });
+        }
     }
     return actions;
 }

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): Promise<RulesAdapterResult>;
-export declare function compileAgentRuleReverts(entry: AgentRuleEntry, agentFilter: AgentId[] | null, home: string): FileWriteRevertAction[];
+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[];

package/dist/core/adapters/rules.js

@@ -2,7 +2,7 @@ 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) {
+export async function compileAgentRuleActions(entry, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, repo) {
     const actions = [];
     const warnings = [];
     const platform = getPlatformKey();
@@ -17,14 +17,14 @@ export async function compileAgentRuleActions(entry, sourceDir, resolvedSourceDi
         if (!support || support.status === "unsupported") {
             warnings.push({
                 kind: "confidence",
-                message: `agentRules: agent "${agentId}" uses ${support?.schemaLabel ?? "an unsupported instruction schema"} and ${support?.reason ?? "does not expose a supported rules adapter"} — skipping "${entry.name}"`,
+                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;
         }
         supportedTargets.push({
             agentId,
             confidence: agent.provenance.agentRules ?? "provisional",
-            target: resolvePlaceholders(support.path[platform], "", home),
+            target: resolvePlaceholders(support.path[platform], entry.name, home, repo),
         });
     }
     if (supportedTargets.length === 0) {
@@ -48,7 +48,7 @@ export async function compileAgentRuleActions(entry, sourceDir, resolvedSourceDi
     }
     return { actions, warnings };
 }
-export function compileAgentRuleReverts(entry, agentFilter, home) {
+export function compileAgentRuleReverts(entry, agentFilter, home, repo) {
     const actions = [];
     const platform = getPlatformKey();
     for (const agentId of entry.agents) {
@@ -58,7 +58,7 @@ export function compileAgentRuleReverts(entry, agentFilter, home) {
         const support = agent?.agentRulesSupport;
         if (!support || support.status === "unsupported")
             continue;
-        const target = resolvePlaceholders(support.path[platform], "", home);
+        const target = resolvePlaceholders(support.path[platform], entry.name, home, repo);
         actions.push({
             kind: "file-write",
             skill: entry.name,

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

@@ -0,0 +1,19 @@
+/**
+ * Reads and parses a TOML file. Returns an empty object if the file does not
+ * exist (treat a missing config.toml as an empty config).
+ */
+export declare function readTomlConfig(filePath: string): Promise<Record<string, unknown>>;
+/**
+ * Merges a named MCP server entry into `config.toml`'s `[mcpServers]` table.
+ * Returns the undo record (the previous value under that key, or null if it
+ * was absent) so revert can restore the exact prior state.
+ */
+export declare function applyTomlMcpPatch(filePath: string, name: string, config: Record<string, unknown>): Promise<{
+    previousValue: unknown | null;
+}>;
+/**
+ * Removes a named MCP server entry from `config.toml`'s `[mcpServers]` table.
+ * If the entry is absent, this is a no-op. If the table becomes empty after
+ * removal, the `mcpServers` key itself is removed from the document.
+ */
+export declare function revertTomlMcpPatch(filePath: string, name: string): Promise<void>;

package/dist/core/adapters/toml.js

@@ -0,0 +1,96 @@
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { parse, stringify } from "smol-toml";
+/**
+ * Reads and parses a TOML file. Returns an empty object if the file does not
+ * exist (treat a missing config.toml as an empty config).
+ */
+export async function readTomlConfig(filePath) {
+    let raw;
+    try {
+        raw = await readFile(filePath, "utf-8");
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            return {};
+        throw err;
+    }
+    const parsed = parse(raw);
+    return parsed;
+}
+function createAtomicTempPath(targetPath) {
+    return `${targetPath}.inception-tmp-${process.pid}-${Date.now()}-${Math.random()
+        .toString(36)
+        .slice(2)}`;
+}
+async function writeTomlConfigAtomic(filePath, obj) {
+    const tempPath = createAtomicTempPath(filePath);
+    try {
+        await mkdir(path.dirname(filePath), { recursive: true });
+        await writeFile(tempPath, stringify(obj), "utf-8");
+        await rename(tempPath, filePath);
+    }
+    catch (err) {
+        try {
+            await rm(tempPath, { force: true });
+        }
+        catch {
+            /* best-effort cleanup */
+        }
+        throw err;
+    }
+}
+/**
+ * Merges a named MCP server entry into `config.toml`'s `[mcpServers]` table.
+ * Returns the undo record (the previous value under that key, or null if it
+ * was absent) so revert can restore the exact prior state.
+ */
+export async function applyTomlMcpPatch(filePath, name, config) {
+    const current = await readTomlConfig(filePath);
+    const mcpServers = typeof current.mcpServers === "object" &&
+        current.mcpServers !== null &&
+        !Array.isArray(current.mcpServers)
+        ? current.mcpServers
+        : {};
+    const previousValue = Object.hasOwn(mcpServers, name)
+        ? mcpServers[name]
+        : null;
+    const patched = {
+        ...current,
+        mcpServers: { ...mcpServers, [name]: config },
+    };
+    await writeTomlConfigAtomic(filePath, patched);
+    return { previousValue };
+}
+/**
+ * Removes a named MCP server entry from `config.toml`'s `[mcpServers]` table.
+ * If the entry is absent, this is a no-op. If the table becomes empty after
+ * removal, the `mcpServers` key itself is removed from the document.
+ */
+export async function revertTomlMcpPatch(filePath, name) {
+    let current;
+    try {
+        current = await readTomlConfig(filePath);
+    }
+    catch {
+        // File gone — nothing to revert.
+        return;
+    }
+    const mcpServers = typeof current.mcpServers === "object" &&
+        current.mcpServers !== null &&
+        !Array.isArray(current.mcpServers)
+        ? current.mcpServers
+        : {};
+    if (!Object.hasOwn(mcpServers, name))
+        return; // already absent
+    const { [name]: _removed, ...remainingServers } = mcpServers;
+    const reverted = { ...current };
+    if (Object.keys(remainingServers).length === 0) {
+        delete reverted.mcpServers;
+    }
+    else {
+        reverted.mcpServers = remainingServers;
+    }
+    await writeTomlConfigAtomic(filePath, reverted);
+}

package/dist/core/deploy.js

@@ -4,7 +4,9 @@ import path from "node:path";
 import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { UserError } from "../errors.js";
 import { logger } from "../logger.js";
+import { writeFrontmatterFile } from "./adapters/frontmatter.js";
 import { compileAdapterActions } from "./adapters/index.js";
+import { applyTomlMcpPatch } from "./adapters/toml.js";
 import { lookupDeployment, registerDeployment, verifyDeployment, } from "./ownership.js";
 import { getDeployMethod, resolveAgentSkillPath } from "./resolve.js";
 import { resolveTargetTemplate } from "./runtime-paths.js";
@@ -80,14 +82,20 @@ function detectCollisions(actions) {
     }
     return warnings;
 }
-function detectAmbiguities(detectedAgents) {
+function detectAmbiguities(detectedAgents, actions, home) {
     const warnings = [];
-    if (detectedAgents.includes("gemini-cli") &&
-        detectedAgents.includes("antigravity")) {
-        warnings.push({
-            kind: "ambiguity",
-            message: 'Both "gemini-cli" and "antigravity" share the ~/.gemini/ base directory. antigravity skill support is implementation-only. Verify that deployed skill paths do not conflict.',
-        });
+    const hasGeminiCli = detectedAgents.includes("gemini-cli");
+    const hasAntigravity = detectedAgents.includes("antigravity");
+    if (hasGeminiCli && hasAntigravity) {
+        const sharedGeminiMd = path.resolve(home, ".gemini", "GEMINI.md");
+        const sharedSettings = path.resolve(home, ".gemini", "settings.json");
+        const targetsShared = actions.some((a) => a.target === sharedGeminiMd || a.target === sharedSettings);
+        if (targetsShared) {
+            warnings.push({
+                kind: "ambiguity",
+                message: "Both 'gemini-cli' and 'antigravity' are active, and a deployment targets a shared surface (~/.gemini/GEMINI.md or settings.json). Because Antigravity treats GEMINI.md as an Agent Blueprint, changes intended for one runtime may unexpectedly affect the other.",
+            });
+        }
     }
     return warnings;
 }
@@ -143,7 +151,7 @@ async function planFileWriteActions(manifest, sourceDir, resolvedSourceDir, real
     }
     return actions;
 }
-function planConfigPatchActions(manifest, detectedAgents, home) {
+function planConfigPatchActions(manifest, detectedAgents, home, repo) {
     const actions = [];
     for (const configEntry of manifest.configs ?? []) {
         for (const agentId of configEntry.agents) {
@@ -156,7 +164,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),
                 patch: configEntry.patch,
                 confidence: agent.provenance.skills,
             });
@@ -176,56 +184,44 @@ export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
     const actions = [
         ...(await planSkillDirActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home)),
         ...(await planFileWriteActions(manifest, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home)),
-        ...planConfigPatchActions(manifest, detectedAgents, home),
+        ...planConfigPatchActions(manifest, detectedAgents, home, resolvedSourceDir),
     ];
-    const adapterResult = await compileAdapterActions(manifest.mcpServers, manifest.agentRules, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home);
+    const adapterResult = await compileAdapterActions(manifest.mcpServers, manifest.agentRules, sourceDir, resolvedSourceDir, realRoot, detectedAgents, home, resolvedSourceDir);
     actions.push(...adapterResult.actions);
     const warnings = [
-        ...detectAmbiguities(detectedAgents),
+        ...detectAmbiguities(detectedAgents, actions, home),
         ...detectCollisions(actions),
         ...adapterResult.warnings,
     ];
     return { actions, warnings };
 }
+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}`);
+    }
+}
 export async function executeDeploy(actions, dryRun, verbose, home, deps = {}) {
     let succeeded = 0;
     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 };
@@ -593,3 +589,87 @@ async function backupExisting(targetPath, verbose, home, expected, deps) {
     await rename(targetPath, backupPath);
     return backupPath;
 }
+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,
+            confidence: action.confidence,
+        });
+        return { error: null };
+    }
+    try {
+        // Guard against double-patching by a different skill/agent.
+        const existingEntry = await lookupDeployment(home, action.target, deps.registry);
+        if (existingEntry &&
+            (existingEntry.skill !== action.skill ||
+                existingEntry.agent !== action.agent)) {
+            throw new Error(`Config "${action.target}" is already patched by skill "${existingEntry.skill}" for agent "${existingEntry.agent}" — refusing to double-patch`);
+        }
+        await applyTomlMcpPatch(action.target, action.skill, action.config);
+        await registerDeployment(home, action.target, {
+            kind: "config-patch",
+            patch: { mcpServers: { [action.skill]: action.config } },
+            undoPatch: { mcpServers: { [action.skill]: null } },
+            skill: action.skill,
+            agent: action.agent,
+        }, deps.registry);
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`patch-toml: wrote [mcpServers.${action.skill}] to ${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,
+            confidence: action.confidence,
+        });
+        return { error: null };
+    }
+    try {
+        // Guard against double-patching by a different skill/agent.
+        const existingEntry = await lookupDeployment(home, action.target, deps.registry);
+        if (existingEntry &&
+            (existingEntry.skill !== action.skill ||
+                existingEntry.agent !== action.agent)) {
+            throw new Error(`File "${action.target}" is already managed by skill "${existingEntry.skill}" for agent "${existingEntry.agent}" — refusing to overwrite`);
+        }
+        await writeFrontmatterFile(action.target, action.frontmatter, {
+            preserveBody: true,
+        });
+        await registerDeployment(home, action.target, {
+            kind: "file-write",
+            source: action.target,
+            skill: action.skill,
+            agent: action.agent,
+        }, deps.registry);
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`emit-frontmatter: wrote ${action.target}`);
+        }
+        return { error: null };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+}

package/dist/core/resolve.d.ts

@@ -9,4 +9,4 @@ export declare function resolveAgentSkillPathFor(agent: AgentConfig, skillName:
 export declare function resolveAgentDetectPathFor(agent: AgentConfig, home: string, platform: "posix" | "windows"): string;
 export declare function resolveAgentSkillPath(agent: AgentConfig, skillName: string, home: string): string;
 export declare function resolveAgentDetectPath(agent: AgentConfig, home: string): string;
-export declare function resolvePlaceholders(segments: string[], skillName: string, home: string): string;
+export declare function resolvePlaceholders(segments: string[], skillName: string, home: string, repo?: string): string;

package/dist/core/resolve.js

@@ -96,13 +96,14 @@ export function resolveAgentSkillPath(agent, skillName, home) {
 export function resolveAgentDetectPath(agent, home) {
     return resolveAgentDetectPathFor(agent, home, getPlatformKey());
 }
-export function resolvePlaceholders(segments, skillName, home) {
+export function resolvePlaceholders(segments, skillName, home, repo) {
     const { appdata, xdgConfig } = resolveRuntimePaths(home);
     const resolved = segments.map((seg) => seg
         .replace("{home}", home)
         .replace("{name}", skillName)
         .replace("{appdata}", appdata)
-        .replace("{xdg_config}", xdgConfig));
+        .replace("{xdg_config}", xdgConfig)
+        .replace("{repo}", repo ?? ""));
     const root = resolved.find((segment) => segment.length > 0) ?? home;
     return getPathApi(root).join(...resolved);
 }

package/dist/core/revert.d.ts

@@ -1,7 +1,7 @@
 import type { AgentId, Manifest, PlannedChange, RevertAction } from "../types.ts";
 import { type RegistryPersistence } from "./ownership.ts";
-export declare function planRevert(manifest: Manifest, detectedAgents: AgentId[], home: string): RevertAction[];
-export declare function planRevertAll(manifest: Manifest, home: string): RevertAction[];
+export declare function planRevert(manifest: Manifest, detectedAgents: AgentId[], home: string, repo?: string): RevertAction[];
+export declare function planRevertAll(manifest: Manifest, home: string, repo?: string): RevertAction[];
 export declare function executeRevert(actions: RevertAction[], dryRun: boolean, verbose: boolean, home: string, deps?: RevertDependencies): Promise<{
     succeeded: number;
     skipped: number;

package/dist/core/revert.js

@@ -2,6 +2,7 @@ import { lstat, readFile, rm, unlink, writeFile } from "node:fs/promises";
 import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { logger } from "../logger.js";
 import { compileAgentRuleReverts, compileMcpServerReverts, } from "./adapters/index.js";
+import { revertTomlMcpPatch } from "./adapters/toml.js";
 import { lookupDeployment, unregisterDeployment, } from "./ownership.js";
 import { resolveAgentSkillPath } from "./resolve.js";
 import { resolveTargetTemplate } from "./runtime-paths.js";
@@ -62,22 +63,22 @@ function buildConfigPatchReverts(manifest, home, agentFilter) {
     }
     return actions;
 }
-export function planRevert(manifest, detectedAgents, home) {
+export function planRevert(manifest, detectedAgents, home, repo) {
     return [
         ...buildSkillDirReverts(manifest, home, detectedAgents),
         ...buildFileWriteReverts(manifest, home, detectedAgents),
         ...buildConfigPatchReverts(manifest, home, detectedAgents),
-        ...(manifest.mcpServers ?? []).flatMap((e) => compileMcpServerReverts(e, detectedAgents, home)),
-        ...(manifest.agentRules ?? []).flatMap((e) => compileAgentRuleReverts(e, detectedAgents, home)),
+        ...(manifest.mcpServers ?? []).flatMap((e) => compileMcpServerReverts(e, detectedAgents, home, repo)),
+        ...(manifest.agentRules ?? []).flatMap((e) => compileAgentRuleReverts(e, detectedAgents, home, repo)),
     ];
 }
-export function planRevertAll(manifest, home) {
+export function planRevertAll(manifest, home, repo) {
     return [
         ...buildSkillDirReverts(manifest, home, null),
         ...buildFileWriteReverts(manifest, home, null),
         ...buildConfigPatchReverts(manifest, home, null),
-        ...(manifest.mcpServers ?? []).flatMap((e) => compileMcpServerReverts(e, null, home)),
-        ...(manifest.agentRules ?? []).flatMap((e) => compileAgentRuleReverts(e, null, home)),
+        ...(manifest.mcpServers ?? []).flatMap((e) => compileMcpServerReverts(e, null, home, repo)),
+        ...(manifest.agentRules ?? []).flatMap((e) => compileAgentRuleReverts(e, null, home, repo)),
     ];
 }
 function recordOutcome(result, action, counts, failed) {
@@ -148,8 +149,21 @@ export async function executeRevert(actions, dryRun, verbose, home, deps = {}) {
             case "config-patch":
                 result = await revertConfigPatch(action, dryRun, verbose, home, planned, deps);
                 break;
+            case "toml-patch":
+                result = await revertTomlPatch(action, dryRun, verbose, home, planned, deps);
+                break;
+            case "frontmatter-emit":
+                // Frontmatter-emit files are fully managed by inception — revert
+                // deletes the file, same as a file-write revert.
+                result = await revertFileWrite({
+                    kind: "file-write",
+                    skill: action.skill,
+                    agent: action.agent,
+                    target: action.target,
+                }, dryRun, verbose, home, planned, deps);
+                break;
             default:
-                throw new Error(`Unhandled revert action kind: ${action}`);
+                throw new Error(`Unhandled revert action kind: ${action.kind}`);
         }
         recordOutcome(result, action, counts, failed);
     }
@@ -316,3 +330,50 @@ async function revertConfigPatch(action, dryRun, verbose, home, planned, deps) {
         return { outcome: "fail", error: msg };
     }
 }
+async function revertTomlPatch(action, dryRun, verbose, home, planned, deps) {
+    const label = `${action.skill} -> ${action.agent}`;
+    try {
+        await lstat(action.target);
+    }
+    catch (err) {
+        const result = lstatOutcome(err);
+        if (result.outcome === "skip") {
+            logger.skip(label, "(not found, skipping)");
+            return result;
+        }
+        logger.fail(label, result.error);
+        return result;
+    }
+    const entry = await lookupDeployment(home, action.target, deps.registry);
+    if (!entry ||
+        entry.kind !== "config-patch" ||
+        entry.skill !== action.skill ||
+        entry.agent !== action.agent) {
+        logger.warn(label, `skipping: ${action.target} is not in the deployment registry — not managed by inception-engine`);
+        return { outcome: "skip" };
+    }
+    if (dryRun) {
+        planned.push({
+            verb: "unapply-patch",
+            kind: "toml-patch",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+        });
+        return { outcome: "ok" };
+    }
+    try {
+        await revertTomlMcpPatch(action.target, action.skill);
+        await unregisterDeployment(home, action.target, deps.registry);
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`removed [mcpServers.${action.skill}] from: ${action.target}`);
+        }
+        return { outcome: "ok" };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { outcome: "fail", error: msg };
+    }
+}

package/dist/core/runtime-paths.d.ts

@@ -5,4 +5,4 @@ export interface RuntimePaths {
 }
 export declare function getPathApi(root: string): typeof path.posix | typeof path.win32;
 export declare function resolveRuntimePaths(home: string): RuntimePaths;
-export declare function resolveTargetTemplate(template: string, home: string): string;
+export declare function resolveTargetTemplate(template: string, home: string, repo?: string): string;

package/dist/core/runtime-paths.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-const TARGET_TEMPLATE_RE = /^\{(home|appdata|xdg_config)\}(?<suffix>(?:[\\/].*)?)$/;
+const TARGET_TEMPLATE_RE = /^\{(home|appdata|xdg_config|repo)\}(?<suffix>(?:[\\/].*)?)$/;
 export function getPathApi(root) {
     if (root.includes("\\") || /^[a-zA-Z]:/.test(root)) {
         return path.win32;
@@ -32,18 +32,31 @@ export function resolveRuntimePaths(home) {
         : homePathApi.join(home, ".config");
     return { appdata, xdgConfig };
 }
-export function resolveTargetTemplate(template, home) {
+export function resolveTargetTemplate(template, home, repo) {
     const { appdata, xdgConfig } = resolveRuntimePaths(home);
     const match = TARGET_TEMPLATE_RE.exec(template);
     if (!match) {
         throw new Error(`Invalid target template: ${template}`);
     }
+    const root = match[1];
+    if (root === "repo") {
+        if (!repo) {
+            throw new Error(`Target template uses {repo} but no manifest directory was provided: ${template}`);
+        }
+        const suffix = match.groups?.suffix ?? "";
+        const segments = suffix.split(/[\\/]+/).filter(Boolean);
+        const repoPathApi = getPathApi(repo);
+        const resolved = segments.length === 0 ? repo : repoPathApi.join(repo, ...segments);
+        if (!isSameOrDescendantPath(resolved, repo)) {
+            throw new Error(`Target template resolves outside its placeholder root: ${template}`);
+        }
+        return suffix === "" ? repo : `${repo}${suffix}`;
+    }
     const baseByRoot = {
         home,
         appdata,
         xdg_config: xdgConfig,
     };
-    const root = match[1];
     const suffix = match.groups?.suffix ?? "";
     const segments = suffix.split(/[\\/]+/).filter(Boolean);
     const pathApi = getPathApi(baseByRoot[root]);

package/dist/schemas/manifest.js

@@ -13,7 +13,9 @@ const SAFE_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 // Target templates must be rooted at a known placeholder and may only add
 // descendant path segments beneath that root. e.g. "{home}/.claude/settings.json"
 // is valid, while "{home}/../.ssh/config" is rejected.
-const TARGET_TEMPLATE_RE = /^\{(home|appdata|xdg_config)\}(?:[\\/].*)?$/;
+// {repo} resolves to the manifest directory at deploy time, enabling repo-local
+// targets (e.g. Antigravity's .agents/rules/ surface).
+const TARGET_TEMPLATE_RE = /^\{(home|appdata|xdg_config|repo)\}(?:[\\/].*)?$/;
 // Standalone schema used for type derivation and single-ID validation (e.g. index.ts).
 export const AgentIdSchema = z.enum(AGENT_IDS);
 // Used inside SkillEntrySchema.agents so that enum failures embed the received
@@ -53,7 +55,7 @@ const targetTemplateField = z
     .string({ message: "target must be a non-empty string" })
     .min(1, { message: "target must be a non-empty string" })
     .refine((t) => TARGET_TEMPLATE_RE.test(t), {
-    message: "target must start with a known placeholder: {home}, {appdata}, or {xdg_config}",
+    message: "target must start with a known placeholder: {home}, {appdata}, {xdg_config}, or {repo}",
 })
     .refine((t) => !t.split(/[\\/]+/).includes(".."), {
     message: "target must not escape its placeholder root",

package/dist/types.d.ts

@@ -9,6 +9,7 @@ export interface SupportedAgentSurface {
     status: "supported";
     path: AgentPaths;
     schemaLabel: string;
+    mcpPatchKey?: string;
 }
 export interface UnsupportedAgentSurface {
     status: "unsupported";
@@ -63,7 +64,23 @@ export interface ConfigPatchDeployAction {
     patch: unknown;
     confidence?: Confidence;
 }
-export type DeployAction = SkillDirDeployAction | FileWriteDeployAction | ConfigPatchDeployAction;
+export interface TomlPatchDeployAction {
+    kind: "toml-patch";
+    skill: string;
+    agent: AgentId;
+    target: string;
+    config: Record<string, unknown>;
+    confidence?: Confidence;
+}
+export interface FrontmatterEmitDeployAction {
+    kind: "frontmatter-emit";
+    skill: string;
+    agent: AgentId;
+    target: string;
+    frontmatter: Record<string, unknown>;
+    confidence?: Confidence;
+}
+export type DeployAction = SkillDirDeployAction | FileWriteDeployAction | ConfigPatchDeployAction | TomlPatchDeployAction | FrontmatterEmitDeployAction;
 export interface SkillDirRevertAction {
     kind: "skill-dir";
     skill: string;
@@ -82,17 +99,30 @@ export interface ConfigPatchRevertAction {
     agent: AgentId;
     target: string;
 }
-export type RevertAction = SkillDirRevertAction | FileWriteRevertAction | ConfigPatchRevertAction;
-export type PlannedChangeVerb = "create-symlink" | "copy-dir" | "write-file" | "patch-config" | "remove" | "unapply-patch";
+export interface TomlPatchRevertAction {
+    kind: "toml-patch";
+    skill: string;
+    agent: AgentId;
+    target: string;
+}
+export interface FrontmatterEmitRevertAction {
+    kind: "frontmatter-emit";
+    skill: string;
+    agent: AgentId;
+    target: string;
+}
+export type RevertAction = SkillDirRevertAction | FileWriteRevertAction | ConfigPatchRevertAction | TomlPatchRevertAction | FrontmatterEmitRevertAction;
+export type PlannedChangeVerb = "create-symlink" | "copy-dir" | "write-file" | "patch-config" | "patch-toml" | "emit-frontmatter" | "remove" | "unapply-patch";
 export interface PlannedChange {
     verb: PlannedChangeVerb;
-    kind: "skill-dir" | "file-write" | "config-patch";
+    kind: "skill-dir" | "file-write" | "config-patch" | "toml-patch" | "frontmatter-emit";
     skill: string;
     agent: AgentId;
     source?: string;
     target: string;
     method?: "symlink" | "copy";
     patch?: Record<string, unknown>;
+    frontmatter?: Record<string, unknown>;
     confidence?: Confidence;
 }
 export interface CliOptions {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kuznai/inception-engine",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Deploy AI agent skills from a git repo to user home directories",
   "license": "MIT",
   "author": "Damian Piątkowski",
@@ -47,6 +47,8 @@
     "test:posix": "node --test --test-isolation=none test/unit/*.test.ts test/os/cross-platform/*.test.ts test/os/posix/*.test.ts"
   },
   "dependencies": {
+    "front-matter": "^4.0.2",
+    "smol-toml": "^1.6.1",
     "zod": "^4.0.0"
   },
   "devDependencies": {