@kuznai/inception-engine 0.17.0 → 0.19.0

package/dist/core/validation.js

@@ -1,6 +1,8 @@
 import { lstat, readFile, realpath, stat } from "node:fs/promises";
 import path from "node:path";
+import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
 import { UserError } from "../errors.js";
+import { parseFrontmatterDocument } from "./adapters/frontmatter.js";
 export function sourceAccessError(err, sourcePath) {
     const code = err.code;
     if (code === "ENOENT")
@@ -147,23 +149,6 @@ export function validateAgentRuleMarkdownPath(manifestPath, agentId) {
         throw new UserError("DEPLOY_FAILED", `agentRules entry "${manifestPath}" for agent "${agentId}" must point to a Markdown source file`);
     }
 }
-function trimMatchingQuotes(value) {
-    if ((value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith("'") && value.endsWith("'"))) {
-        return value.slice(1, -1).trim();
-    }
-    return value;
-}
-function parseSimpleFrontmatterValue(field, rawValue, manifestPath) {
-    const value = trimMatchingQuotes(rawValue.trim());
-    if (value.length === 0) {
-        throw new UserError("DEPLOY_FAILED", `Skill "${manifestPath}" SKILL.md frontmatter field "${field}" must be a non-empty string`);
-    }
-    if (rawValue.trim() === "|" || rawValue.trim() === ">") {
-        throw new UserError("DEPLOY_FAILED", `Skill "${manifestPath}" SKILL.md frontmatter field "${field}" must be a single-line string`);
-    }
-    return value;
-}
 export async function validateSkillDefinitionFile(sourcePath, manifestPath) {
     await validateSourceFile(sourcePath, `${manifestPath}/SKILL.md`);
     let raw;
@@ -181,27 +166,80 @@ export async function validateSkillDefinitionFile(sourcePath, manifestPath) {
     if (closingIndex === -1) {
         throw new UserError("DEPLOY_FAILED", `Skill "${manifestPath}" SKILL.md is missing the closing --- frontmatter delimiter`);
     }
-    let name = null;
-    let description = null;
-    for (const line of lines.slice(1, closingIndex)) {
-        const trimmed = line.trim();
-        if (trimmed.length === 0 || trimmed.startsWith("#"))
-            continue;
-        const match = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/.exec(line);
-        if (!match)
-            continue;
-        const [, key, rawValue] = match;
-        if (key === "name") {
-            name = parseSimpleFrontmatterValue("name", rawValue, manifestPath);
+    let attributes;
+    let body;
+    try {
+        const parsed = parseFrontmatterDocument(raw);
+        attributes = parsed.attributes;
+        body = parsed.body;
+    }
+    catch (err) {
+        throw new UserError("DEPLOY_FAILED", `Skill "${manifestPath}" SKILL.md has malformed YAML frontmatter: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const validateField = (field) => {
+        const value = attributes[field];
+        if (value === undefined || value === null) {
+            throw new UserError("DEPLOY_FAILED", `Skill "${manifestPath}" SKILL.md frontmatter must include a non-empty "${field}" field`);
+        }
+        if (typeof value !== "string" || value.trim().length === 0) {
+            throw new UserError("DEPLOY_FAILED", `Skill "${manifestPath}" SKILL.md frontmatter field "${field}" must be a non-empty string`);
+        }
+        if (value.includes("\n") || value.includes("\r")) {
+            throw new UserError("DEPLOY_FAILED", `Skill "${manifestPath}" SKILL.md frontmatter field "${field}" must be a single-line string`);
+        }
+    };
+    validateField("name");
+    validateField("description");
+    return { attributes, body };
+}
+function validateGithubCopilotRequirements(attributes, manifestPath) {
+    const hasTools = Object.hasOwn(attributes, "tools");
+    const hasInstructions = Object.hasOwn(attributes, "instructions");
+    if (!(hasTools || hasInstructions)) {
+        throw new UserError("DEPLOY_FAILED", `Instruction file "${manifestPath}" for agent "github-copilot" must define "tools" or "instructions" in frontmatter`);
+    }
+}
+function validateAntigravityRequirements(attributes, manifestPath) {
+    const mcpServers = attributes["mcp-servers"] ?? attributes.mcpServers;
+    if (mcpServers === undefined)
+        return;
+    if (typeof mcpServers !== "object" ||
+        mcpServers === null ||
+        Array.isArray(mcpServers)) {
+        throw new UserError("DEPLOY_FAILED", `Instruction file "${manifestPath}" for agent "antigravity" must define "mcp-servers" as an object`);
+    }
+    for (const [name, config] of Object.entries(mcpServers)) {
+        if (typeof config !== "object" ||
+            config === null ||
+            Array.isArray(config)) {
+            throw new UserError("DEPLOY_FAILED", `Instruction file "${manifestPath}" for agent "antigravity" has malformed MCP server config for "${name}"`);
         }
-        else if (key === "description") {
-            description = parseSimpleFrontmatterValue("description", rawValue, manifestPath);
+        validateMcpServerConfigShape(config, name, "antigravity");
+    }
+}
+/**
+ * Validates that an instruction file (agentRules or agentDefinitions) meets
+ * the structural requirements of the target agent.
+ */
+export async function validateInstructionFileRequirements(sourcePath, manifestPath, agentId) {
+    const requiresFrontmatter = AGENT_REGISTRY_BY_ID[agentId]?.instructionFrontmatterRequired === true;
+    if (!requiresFrontmatter)
+        return;
+    let attributes;
+    try {
+        const result = await validateSkillDefinitionFile(sourcePath, manifestPath);
+        attributes = result.attributes;
+    }
+    catch (err) {
+        if (err instanceof UserError) {
+            throw new UserError("DEPLOY_FAILED", `Instruction file "${manifestPath}" for agent "${agentId}" failed structural validation: ${err.message}`);
         }
+        throw err;
     }
-    if (name === null) {
-        throw new UserError("DEPLOY_FAILED", `Skill "${manifestPath}" SKILL.md frontmatter must include a non-empty "name" field`);
+    if (agentId === "github-copilot") {
+        validateGithubCopilotRequirements(attributes, manifestPath);
     }
-    if (description === null) {
-        throw new UserError("DEPLOY_FAILED", `Skill "${manifestPath}" SKILL.md frontmatter must include a non-empty "description" field`);
+    else if (agentId === "antigravity") {
+        validateAntigravityRequirements(attributes, manifestPath);
     }
 }

package/dist/formatters.d.ts

@@ -0,0 +1,5 @@
+import type { PlannedChange } from "./types.ts";
+/**
+ * Groups and formats the dry-run plan by agent.
+ */
+export declare function formatDryRunPlan(planned: PlannedChange[]): string;

package/dist/formatters.js

@@ -0,0 +1,58 @@
+import { styleText } from "node:util";
+/**
+ * Groups and formats the dry-run plan by agent.
+ */
+export function formatDryRunPlan(planned) {
+    if (planned.length === 0)
+        return "";
+    const groups = new Map();
+    for (const change of planned) {
+        const list = groups.get(change.agent) ?? [];
+        list.push(change);
+        groups.set(change.agent, list);
+    }
+    const sortedAgents = Array.from(groups.keys()).sort();
+    const output = [];
+    for (const agent of sortedAgents) {
+        output.push(styleText(["bold", "yellow"], agent));
+        const changes = groups.get(agent);
+        if (!changes)
+            continue;
+        for (const change of changes) {
+            output.push(formatPlannedChange(change));
+        }
+        output.push("");
+    }
+    return output.join("\n");
+}
+function formatPlannedChange(change) {
+    const icon = styleText("cyan", "○");
+    const kind = styleText("dim", `[${change.kind}]`);
+    const lines = [
+        `  ${icon} ${kind} ${change.verb} ${styleText("bold", change.skill)}`,
+    ];
+    if (change.source !== undefined) {
+        lines.push(`    source: ${styleText("dim", change.source)}`);
+    }
+    lines.push(`    target: ${styleText("dim", change.target)}`);
+    const detail = formatChangeDetail(change);
+    if (detail) {
+        lines.push(`    ${detail}`);
+    }
+    return lines.join("\n");
+}
+function formatChangeDetail(change) {
+    if (change.verb === "patch-config" && change.patch !== undefined) {
+        return `patch:  ${styleText("dim", JSON.stringify(change.patch))}`;
+    }
+    if (change.verb === "unapply-patch" && change.patch !== undefined) {
+        return `undo:   ${styleText("dim", JSON.stringify(change.patch))}`;
+    }
+    if (change.verb === "patch-toml" && change.patch !== undefined) {
+        return `patch:  ${styleText("dim", JSON.stringify(change.patch))}`;
+    }
+    if (change.verb === "emit-frontmatter" && change.frontmatter !== undefined) {
+        return `frontmatter: ${styleText("dim", JSON.stringify(change.frontmatter))}`;
+    }
+    return null;
+}

package/dist/index.js

@@ -10,6 +10,7 @@ import { runPreflight } from "./core/preflight.js";
 import { resolveHome } from "./core/resolve.js";
 import { executeRevert, planRevert, planRevertAll } from "./core/revert.js";
 import { UserError } from "./errors.js";
+import { formatDryRunPlan } from "./formatters.js";
 import { dryRunPrefix, logger } from "./logger.js";
 import { AgentListSchema } from "./schemas/manifest.js";
 const USAGE = `
@@ -26,7 +27,7 @@ Commands:
   init <directory>    Scan a directory for skill folders and generate inception.json
 
 Options:
-  --dry-run        Show what would be done without doing it
+  --plan           Show what would be done without doing it
   --agents <list>  Comma-separated list of agent IDs to target
   --force          (init only) Overwrite an existing inception.json
   --verbose        Show detailed output
@@ -55,7 +56,7 @@ function parseCLI(argv) {
             args,
             allowPositionals: true,
             options: {
-                "dry-run": { type: "boolean", default: false },
+                plan: { type: "boolean", default: false },
                 verbose: { type: "boolean", default: false },
                 debug: { type: "boolean", default: false },
                 help: { type: "boolean", default: false },
@@ -107,7 +108,7 @@ function parseCLI(argv) {
     return {
         command,
         directory: path.resolve(rawDir),
-        dryRun: values["dry-run"],
+        dryRun: (values.plan || values["dry-run"]),
         agents,
         verbose: values.verbose,
         debug: values.debug,
@@ -136,21 +137,6 @@ async function main() {
     }
     return runRevert(options, manifest, home);
 }
-function renderDryRunPlan(planned) {
-    for (const change of planned) {
-        logger.plan(`[${change.agent}] ${change.verb}  ${change.skill}`);
-        if (change.source !== undefined) {
-            logger.detail(`source: ${change.source}`);
-        }
-        logger.detail(`target: ${change.target}`);
-        if (change.verb === "patch-config" && change.patch !== undefined) {
-            logger.detail(`patch:  ${JSON.stringify(change.patch)}`);
-        }
-        else if (change.verb === "unapply-patch" && change.patch !== undefined) {
-            logger.detail(`undo:   ${JSON.stringify(change.patch)}`);
-        }
-    }
-}
 async function runDeploy(options, manifest, home) {
     let detectedAgents;
     if (options.agents) {
@@ -187,9 +173,8 @@ async function runDeploy(options, manifest, home) {
     const { succeeded, failed, planned } = await executeDeploy(actions, options.dryRun, options.verbose, home);
     if (options.dryRun) {
         logger.info("");
-        renderDryRunPlan(planned);
-        logger.info("");
-        logger.info(`${planned.length} action(s) would be applied (dry-run)`);
+        logger.info(formatDryRunPlan(planned));
+        logger.info(`${planned.length} action(s) would be applied (plan)`);
         return 0;
     }
     logger.info("");
@@ -212,9 +197,8 @@ async function runRevert(options, manifest, home) {
     const { succeeded, skipped, failed, planned } = await executeRevert(actions, options.dryRun, options.verbose, home);
     if (options.dryRun) {
         logger.info("");
-        renderDryRunPlan(planned);
-        logger.info("");
-        logger.info(`${planned.length} action(s) would be removed (dry-run)`);
+        logger.info(formatDryRunPlan(planned));
+        logger.info(`${planned.length} action(s) would be removed (plan)`);
         return 0;
     }
     logger.info("");

package/dist/logger.js

@@ -1,36 +1,37 @@
 import process from "node:process";
-const C = {
-    red: "\x1b[31m",
-    green: "\x1b[32m",
-    yellow: "\x1b[33m",
-    cyan: "\x1b[36m",
-    reset: "\x1b[0m",
-};
+import { styleText } from "node:util";
 export function createLogger() {
     let silent = false;
-    const tty = Boolean(process.stdout.isTTY);
-    const errTTY = Boolean(process.stderr.isTTY);
-    const c = (col, text, onTTY) => onTTY ? `${C[col]}${text}${C.reset}` : text;
     return {
         fail(label, msg) {
-            if (!silent)
-                process.stderr.write(`  ${c("red", "✗", errTTY)} ${label}: ${msg}\n`);
+            if (!silent) {
+                const icon = styleText("red", "✗");
+                process.stderr.write(`  ${icon} ${label}: ${msg}\n`);
+            }
         },
         ok(label) {
-            if (!silent)
-                process.stdout.write(`  ${c("green", "✓", tty)} ${label}\n`);
+            if (!silent) {
+                const icon = styleText("green", "✓");
+                process.stdout.write(`  ${icon} ${label}\n`);
+            }
         },
         skip(label, note) {
-            if (!silent)
-                process.stdout.write(`  ${c("yellow", "-", tty)} ${label} ${note}\n`);
+            if (!silent) {
+                const icon = styleText("yellow", "-");
+                process.stdout.write(`  ${icon} ${label} ${note}\n`);
+            }
         },
         plan(label) {
-            if (!silent)
-                process.stdout.write(`  ${c("cyan", "○", tty)} ${label}\n`);
+            if (!silent) {
+                const icon = styleText("cyan", "○");
+                process.stdout.write(`  ${icon} ${label}\n`);
+            }
         },
         warn(label, msg) {
-            if (!silent)
-                process.stdout.write(`  ${c("yellow", "!", tty)} ${label}: ${msg}\n`);
+            if (!silent) {
+                const icon = styleText("yellow", "!");
+                process.stdout.write(`  ${icon} ${label}: ${msg}\n`);
+            }
         },
         info(msg) {
             if (!silent)
@@ -57,5 +58,5 @@ export const logger = createLogger();
 export function dryRunPrefix(dryRun) {
     if (!dryRun)
         return "";
-    return process.stdout.isTTY ? `\x1b[36m[dry-run]\x1b[0m ` : `[dry-run] `;
+    return styleText("cyan", "[plan] ");
 }

package/dist/schemas/manifest.d.ts

@@ -71,6 +71,11 @@ export declare const AgentRuleEntrySchema: z.ZodObject<{
         "github-copilot": "github-copilot";
     }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
     path: z.ZodString;
+    scope: z.ZodDefault<z.ZodEnum<{
+        global: "global";
+        repo: "repo";
+        workspace: "workspace";
+    }>>;
 }, z.core.$strip>;
 export declare const PermissionsEntrySchema: z.ZodObject<{
     name: z.ZodString;
@@ -158,6 +163,11 @@ export declare const ManifestSchema: z.ZodObject<{
             "github-copilot": "github-copilot";
         }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
         path: z.ZodString;
+        scope: z.ZodDefault<z.ZodEnum<{
+            global: "global";
+            repo: "repo";
+            workspace: "workspace";
+        }>>;
     }, z.core.$strip>>>;
     permissions: z.ZodDefault<z.ZodArray<z.ZodObject<{
         name: z.ZodString;

package/dist/schemas/manifest.js

@@ -15,7 +15,7 @@ const SAFE_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 // is valid, while "{home}/../.ssh/config" is rejected.
 // {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)\}(?:[\\/].*)?$/;
+const TARGET_TEMPLATE_RE = /^\{(home|appdata|xdg_config|repo|workspace)\}(?:[\\/].*)?$/;
 // 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
@@ -88,7 +88,14 @@ export const AgentRuleEntrySchema = z.object({
     name: nameField,
     agents: agentsField,
     // Relative path to the rules/instruction file within the source bundle.
+    // Must be a .md or .markdown file. Structural requirements (e.g. YAML
+    // frontmatter) are validated per agent requirements by the adapter.
     path: sourcePathField,
+    // Deployment scope: "global" targets the agent's home-directory instruction
+    // file (default), "repo" targets the project-root instruction file within the
+    // deployed repository (e.g. {repo}/CLAUDE.md for claude-code), and "workspace"
+    // targets the agent's workspace-local instruction surface.
+    scope: z.enum(["global", "repo", "workspace"]).default("global"),
 });
 export const PermissionsEntrySchema = z.object({
     name: nameField,
@@ -102,8 +109,8 @@ export const AgentDefinitionEntrySchema = z.object({
     name: nameField,
     agents: agentsField,
     // Relative path to the agent definition Markdown file within the source bundle.
-    // Must be a .md or .markdown file containing YAML frontmatter that describes
-    // the agent's persona, instructions, and any tool configuration.
+    // Must be a .md or .markdown file. Structural requirements (e.g. YAML
+    // frontmatter) are validated per agent requirements by the adapter.
     path: sourcePathField,
 });
 export const ManifestSchema = z.object({

package/dist/schemas/registry.d.ts

@@ -46,6 +46,19 @@ declare const ConfigPatchRegistryEntrySchema: z.ZodObject<{
     }>;
     deployed: z.ZodString;
 }, z.core.$strip>;
+declare const FrontmatterEmitRegistryEntrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"frontmatter-emit">;
+    skill: z.ZodString;
+    agent: z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+        "gemini-cli": "gemini-cli";
+        antigravity: "antigravity";
+        opencode: "opencode";
+        "github-copilot": "github-copilot";
+    }>;
+    deployed: z.ZodString;
+}, z.core.$strip>;
 export declare const RegistryEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"skill-dir">;
     source: z.ZodString;
@@ -90,6 +103,18 @@ export declare const RegistryEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         "github-copilot": "github-copilot";
     }>;
     deployed: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"frontmatter-emit">;
+    skill: z.ZodString;
+    agent: z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+        "gemini-cli": "gemini-cli";
+        antigravity: "antigravity";
+        opencode: "opencode";
+        "github-copilot": "github-copilot";
+    }>;
+    deployed: z.ZodString;
 }, z.core.$strip>], "kind">;
 export declare const RegistrySchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
@@ -137,11 +162,24 @@ export declare const RegistrySchema: z.ZodObject<{
             "github-copilot": "github-copilot";
         }>;
         deployed: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"frontmatter-emit">;
+        skill: z.ZodString;
+        agent: z.ZodEnum<{
+            "claude-code": "claude-code";
+            codex: "codex";
+            "gemini-cli": "gemini-cli";
+            antigravity: "antigravity";
+            opencode: "opencode";
+            "github-copilot": "github-copilot";
+        }>;
+        deployed: z.ZodString;
     }, z.core.$strip>], "kind">>;
 }, z.core.$strip>;
 export type SkillDirRegistryEntry = z.infer<typeof SkillDirRegistryEntrySchema>;
 export type FileWriteRegistryEntry = z.infer<typeof FileWriteRegistryEntrySchema>;
 export type ConfigPatchRegistryEntry = z.infer<typeof ConfigPatchRegistryEntrySchema>;
+export type FrontmatterEmitRegistryEntry = z.infer<typeof FrontmatterEmitRegistryEntrySchema>;
 export type RegistryEntry = z.infer<typeof RegistryEntrySchema>;
 export type Registry = z.infer<typeof RegistrySchema>;
 export {};

package/dist/schemas/registry.js

@@ -23,10 +23,17 @@ const ConfigPatchRegistryEntrySchema = z.object({
     agent: AgentIdSchema,
     deployed: z.string(),
 });
+const FrontmatterEmitRegistryEntrySchema = z.object({
+    kind: z.literal("frontmatter-emit"),
+    skill: z.string(),
+    agent: AgentIdSchema,
+    deployed: z.string(),
+});
 export const RegistryEntrySchema = z.discriminatedUnion("kind", [
     SkillDirRegistryEntrySchema,
     FileWriteRegistryEntrySchema,
     ConfigPatchRegistryEntrySchema,
+    FrontmatterEmitRegistryEntrySchema,
 ]);
 export const RegistrySchema = z.object({
     version: z.literal(1),

package/dist/types.d.ts

@@ -7,6 +7,33 @@ export interface AgentPaths {
 export type Confidence = "documented" | "implementation-only" | "provisional";
 export interface SupportedAgentSurface {
     status: "supported";
+    /**
+     * Declares how this agent relates to the surface:
+     * - "agent-specific" (default when absent): the agent owns this surface
+     *   independently and deploy emits a normal action.
+     * - "native": the agent reads this surface autonomously without any deploy
+     *   action from inception-engine; no action is emitted.
+     * - "shared-via": this agent rides another agent's deployment. When the
+     *   primary agent (`via`) is also in the target list, deploy skips this
+     *   agent's action (the primary writes the shared file). When the primary
+     *   is absent, a guidance warning is emitted instead.
+     */
+    surfaceKind?: {
+        kind: "agent-specific";
+    } | {
+        kind: "native";
+    } | {
+        kind: "shared-via";
+        via: AgentId;
+        /**
+         * When true, this agent cannot deploy to the surface independently —
+         * the primary agent (`via`) must also be in the target list. If the
+         * primary is absent, a guidance warning is emitted and no action is
+         * generated. When false or absent, the agent can deploy to the surface
+         * on its own if the primary is not present.
+         */
+        requiresPrimary?: boolean;
+    };
     path: AgentPaths;
     schemaLabel: string;
     mcpPatchKey?: string;
@@ -50,14 +77,35 @@ export interface AgentConfig {
      * (e.g. GitHub Copilot reads `.claude/skills/` directly).
      */
     skills?: AgentPaths;
+    /**
+     * When `skills` is absent, this field explains why. Currently only
+     * "shared-via" is used — the agent reads skills from the `via` agent's
+     * deployment path natively and needs no separate skills deploy action.
+     */
+    skillsSurfaceKind?: {
+        kind: "shared-via";
+        via: AgentId;
+    };
     detectPaths: AgentPaths;
     detectBinary: string | null;
     provenance: AgentProvenance;
     mcpSupport?: AgentSurfaceSupport;
     agentRulesSupport?: AgentSurfaceSupport;
+    agentRulesRepoSupport?: AgentSurfaceSupport;
+    agentRulesWorkspaceSupport?: AgentSurfaceSupport;
     permissionsSupport?: AgentSurfaceSupport;
     agentDefinitionsSupport?: AgentSurfaceSupport;
     policyNote?: string;
+    /**
+     * When true, instruction files deployed to this agent must include valid
+     * YAML frontmatter. Drives validateInstructionFileRequirements without
+     * hardcoded agent-ID checks.
+     */
+    instructionFrontmatterRequired?: boolean;
+    /**
+     * When true, preflight runs enterprise-policy detection for this agent.
+     */
+    enterprisePolicyDetection?: boolean;
 }
 export interface PlanWarning {
     kind: "confidence" | "collision" | "ambiguity";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kuznai/inception-engine",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "Deploy AI agent skills from a git repo to user home directories",
   "license": "MIT",
   "author": "Damian Piątkowski",
@@ -47,8 +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",
+    "yaml": "^2.8.3",
     "zod": "^4.0.0"
   },
   "devDependencies": {