@kuznai/inception-engine 0.6.0 → 0.7.0

package/README.md

@@ -2,7 +2,7 @@
 
 Plant skills directly into the minds of your installed AI coding agents — Claude Code, Codex, Gemini CLI, Antigravity, OpenCode, and GitHub Copilot. One command. They'll think they thought of it themselves.
 
-Today, inception-engine is a skills deployer. It does not yet manage persistent instruction files, MCP configuration, subagents, or agent-specific config patching.
+Today, inception-engine is a skills deployer. The public manifest and CLI planner currently deploy and revert skill directories only. The core executor also has internal support for single-file write and JSON config patch actions, but the manifest format does not expose them yet. MCP configuration and agent-specific config patching remain unimplemented at the manifest level.
 
 ## Quick Start
 
@@ -40,9 +40,11 @@ Managed skills overwrite their previous version. If a target exists but was not
 
 | Feature | Status |
 |---|---|
-| Skills (SKILL.md) | Supported |
-| MCP Servers | Accepted in manifest, not implemented |
-| Agent Rules | Accepted in manifest, not implemented |
+| Skills (SKILL.md) | Supported via manifest and CLI |
+| File write | Internal executor support only; not exposed in manifest or CLI planning |
+| Config patch (JSON merge) | Internal executor support only; not exposed in manifest or CLI planning |
+| MCP Servers | Accepted in manifest for forward compatibility, not implemented |
+| Agent Rules | Accepted in manifest for forward compatibility, not implemented |
 
 ## Manifest Format
 
@@ -68,7 +70,7 @@ Each skill entry has:
 - **path** - Relative path to the skill directory within the repo
 - **agents** - Array of agent IDs to deploy this skill to. If an agent isn't installed, it's skipped.
 
-`mcpServers` and `agentRules` are currently parsed for forward compatibility, but the deployment engine ignores them today.
+`mcpServers` and `agentRules` are currently parsed for forward compatibility, but the deployment engine ignores them today. The manifest-driven planner and revert flow currently derive actions from `skills` entries only.
 
 ## Creating Skills
 
@@ -165,7 +167,7 @@ inception-engine maintains a centralized deployment registry at `~/.inception-en
 
 - **Registry-based ownership**: On revert, the registry is checked before removing any target. Only targets with a valid registry entry are removed. On redeploy, unmanaged targets are never replaced.
 
-- **Strong binding**: Each registry entry binds a specific target path to its source, skill, agent, and deploy method. A target is only considered managed if all fields match — a stray entry or a different deployment cannot satisfy the check.
+- **Strong binding**: Each registry entry binds a specific target path to its skill, agent, and action kind, with action-specific provenance fields (`source` and `method` for skill-dir and file-write; `patch` and `undoPatch` for config-patch). A target is only considered managed if all relevant fields match — a stray entry or a different deployment cannot satisfy the check.
 
 - **Atomic redeploy**: When overwriting an existing managed target, the engine renames the old target to a backup, creates the new deployment, and only removes the backup on success. If the new deployment fails, the backup is restored.
 
@@ -201,7 +203,10 @@ Windows deployment currently uses directory-level copy (one `cp -r` per skill).
 
 ## Requirements
 
-- Node.js >= 23.6.0
+- Published CLI runtime: Node.js >= 22.3.0
+- Direct TypeScript execution in this repo (`npm run dev`, `npm test`): Node.js >= 22.18.0
+
+`inception-engine` publishes compiled JavaScript from `dist/`, so end users do not need the newer Node version required for this repository's direct `.ts` workflows. The higher contributor floor exists only because this repo intentionally runs TypeScript straight through `node` for local development and tests, with no `tsx`, `ts-node`, or experimental TypeScript flags.
 
 ## License
 

package/dist/config/manifest.js

@@ -1,8 +1,8 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
+import { UserError } from "../errors.js";
 import { formatZodPath } from "../schemas/errors.js";
 import { ManifestSchema } from "../schemas/manifest.js";
-import { UserError } from "../errors.js";
 export async function loadManifest(directory) {
     const manifestPath = path.join(directory, "inception.json");
     let raw;
@@ -38,6 +38,11 @@ function validateManifest(data, filePath) {
         if (issuePath.length === 1 && issuePath[0] === "skills") {
             throw new UserError("MANIFEST_INVALID", `${filePath}: "skills" must be an array`);
         }
+        // Top-level "mcpServers" or "agentRules": wrong type → uniform message
+        if (issuePath.length === 1 &&
+            (issuePath[0] === "mcpServers" || issuePath[0] === "agentRules")) {
+            throw new UserError("MANIFEST_INVALID", `${filePath}: "${issuePath[0]}" must be an array`);
+        }
         throw new UserError("MANIFEST_INVALID", `${filePath}: ${formatZodPath(issuePath)}${issue.message}`);
     }
     return result.data;

package/dist/core/deploy.d.ts

@@ -1,9 +1,13 @@
-import type { AgentId, DeployAction, Manifest } from "../types.ts";
-export declare function planDeploy(manifest: Manifest, sourceDir: string, detectedAgents: AgentId[], home: string): Promise<DeployAction[]>;
+import type { AgentId, DeployAction, Manifest, PlannedChange, PlanWarning } from "../types.ts";
+export declare function planDeploy(manifest: Manifest, sourceDir: string, detectedAgents: AgentId[], home: string): Promise<{
+    actions: DeployAction[];
+    warnings: PlanWarning[];
+}>;
 export declare function executeDeploy(actions: DeployAction[], dryRun: boolean, verbose: boolean, home: string): Promise<{
     succeeded: number;
     failed: Array<{
         action: DeployAction;
         error: string;
     }>;
+    planned: PlannedChange[];
 }>;

package/dist/core/deploy.js

@@ -1,10 +1,55 @@
-import { access, cp, lstat, mkdir, realpath, rename, rm, symlink, unlink, } from "node:fs/promises";
+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 { UserError } from "../errors.js";
 import { logger } from "../logger.js";
-import { registerDeployment, verifyDeployment } from "./ownership.js";
+import { lookupDeployment, registerDeployment, verifyDeployment, } from "./ownership.js";
 import { getDeployMethod, resolveAgentSkillPath } from "./resolve.js";
+function isPlainObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+async function readJsonConfig(filePath) {
+    let rawContent;
+    try {
+        rawContent = await readFile(filePath, "utf-8");
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT")
+            throw new Error(`Config file not found: ${filePath}`);
+        throw err;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(rawContent);
+    }
+    catch {
+        throw new Error(`Config file is not valid JSON: ${filePath}`);
+    }
+    if (!isPlainObject(parsed)) {
+        throw new Error(`Config file is not a JSON object: ${filePath}`);
+    }
+    return parsed;
+}
+function computeUndoPatch(original, patch) {
+    const undoPatch = {};
+    for (const key of Object.keys(patch)) {
+        undoPatch[key] = key in original ? original[key] : null;
+    }
+    return undoPatch;
+}
+function applyMergePatch(original, patch) {
+    const patched = { ...original };
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === null) {
+            delete patched[key];
+        }
+        else {
+            patched[key] = value;
+        }
+    }
+    return patched;
+}
 function sourceAccessError(err, sourcePath) {
     const code = err.code;
     if (code === "ENOENT")
@@ -14,6 +59,34 @@ function sourceAccessError(err, sourcePath) {
     const detail = err instanceof Error ? err.message : String(err);
     return `Failed to access source ${sourcePath}: ${detail}`;
 }
+function detectCollisions(actions) {
+    const seen = new Map();
+    const warnings = [];
+    for (const action of actions) {
+        const prev = seen.get(action.target);
+        if (prev) {
+            warnings.push({
+                kind: "collision",
+                message: `Skill "${action.skill}" for agent "${action.agent}" and skill "${prev.skill}" for agent "${prev.agent}" both resolve to the same target: ${action.target}`,
+            });
+        }
+        else {
+            seen.set(action.target, { skill: action.skill, agent: action.agent });
+        }
+    }
+    return warnings;
+}
+function detectAmbiguities(detectedAgents) {
+    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.',
+        });
+    }
+    return warnings;
+}
 export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
     const method = getDeployMethod();
     const actions = [];
@@ -28,6 +101,7 @@ export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
     for (const skill of manifest.skills) {
         const source = path.resolve(sourceDir, skill.path);
         await validateSourcePath(source, skill.path, resolvedSourceDir, realRoot);
+        await validateSkillContract(source, skill.path);
         for (const agentId of skill.agents) {
             if (!detectedAgents.includes(agentId))
                 continue;
@@ -36,49 +110,213 @@ export async function planDeploy(manifest, sourceDir, detectedAgents, home) {
                 continue;
             const target = resolveAgentSkillPath(agent, skill.name, home);
             actions.push({
+                kind: "skill-dir",
                 skill: skill.name,
                 agent: agentId,
                 source,
                 target,
                 method,
+                confidence: agent.provenance.skills,
             });
         }
     }
-    return actions;
+    const warnings = [
+        ...detectAmbiguities(detectedAgents),
+        ...detectCollisions(actions),
+    ];
+    return { actions, warnings };
 }
 export async function executeDeploy(actions, dryRun, verbose, home) {
     let succeeded = 0;
     const failed = [];
+    const planned = [];
     for (const action of actions) {
-        const label = `${action.skill} -> ${action.agent}`;
+        switch (action.kind) {
+            case "skill-dir": {
+                const result = await deploySkillDir(action, dryRun, verbose, home, planned);
+                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);
+                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);
+                if (result.error === null) {
+                    succeeded++;
+                }
+                else {
+                    failed.push({ action, error: result.error });
+                }
+                break;
+            }
+            default: {
+                throw new Error(`Unhandled deploy action kind: ${action}`);
+            }
+        }
+    }
+    return { succeeded, failed, planned };
+}
+async function deploySkillDir(action, dryRun, verbose, home, planned) {
+    const label = `${action.skill} -> ${action.agent}`;
+    try {
+        await access(action.source);
+    }
+    catch (err) {
+        const msg = sourceAccessError(err, action.source);
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+    if (dryRun) {
+        logger.plan(label);
+        logger.detail(`${action.method}: ${action.source} -> ${action.target}`);
+        planned.push({
+            verb: action.method === "symlink" ? "create-symlink" : "copy-dir",
+            kind: "skill-dir",
+            skill: action.skill,
+            agent: action.agent,
+            source: action.source,
+            target: action.target,
+            method: action.method,
+            confidence: action.confidence,
+        });
+        return { error: null };
+    }
+    try {
+        await executeDeployAction(action, verbose, home);
+        return { error: null };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+}
+async function deployFileWrite(action, dryRun, verbose, home, planned) {
+    const label = `${action.skill} -> ${action.agent}`;
+    try {
+        await access(action.source);
+    }
+    catch (err) {
+        const msg = sourceAccessError(err, action.source);
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+    if (dryRun) {
+        logger.plan(label);
+        logger.detail(`write-file: ${action.source} -> ${action.target}`);
+        planned.push({
+            verb: "write-file",
+            kind: "file-write",
+            skill: action.skill,
+            agent: action.agent,
+            source: action.source,
+            target: action.target,
+        });
+        return { error: null };
+    }
+    try {
+        // Check if target exists — only allow overwrite if we own it
         try {
-            await access(action.source);
+            await lstat(action.target);
+            const isOwned = await verifyDeployment(home, action.target, {
+                kind: "file-write",
+                source: action.source,
+                skill: action.skill,
+                agent: action.agent,
+            });
+            if (!isOwned) {
+                throw new Error(`Target "${action.target}" exists but is not managed by inception-engine — refusing to overwrite`);
+            }
         }
         catch (err) {
-            const msg = sourceAccessError(err, action.source);
-            failed.push({ action, error: msg });
-            logger.fail(label, msg);
-            continue;
+            if (err instanceof Error && err.message.includes("refusing to overwrite"))
+                throw err;
+            // ENOENT — target doesn't exist, fine to create
         }
-        if (dryRun) {
-            logger.plan(label);
-            if (verbose) {
-                logger.detail(`${action.method}: ${action.source} -> ${action.target}`);
-            }
-            succeeded++;
-            continue;
+        await mkdir(path.dirname(action.target), { recursive: true });
+        await copyFile(action.source, action.target);
+        await registerDeployment(home, action.target, {
+            kind: "file-write",
+            source: action.source,
+            skill: action.skill,
+            agent: action.agent,
+        });
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`write-file: ${action.source} -> ${action.target}`);
         }
-        try {
-            await executeDeployAction(action, verbose, home);
-            succeeded++;
+        return { error: null };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+}
+async function deployConfigPatch(action, dryRun, verbose, home, planned) {
+    const label = `${action.skill} -> ${action.agent}`;
+    if (!isPlainObject(action.patch)) {
+        const msg = `Config patch for skill "${action.skill}" must be a plain object`;
+        logger.fail(label, msg);
+        return { error: msg };
+    }
+    const patch = action.patch;
+    if (dryRun) {
+        logger.plan(label);
+        logger.detail(`patch-config: ${JSON.stringify(patch)} -> ${action.target}`);
+        planned.push({
+            verb: "patch-config",
+            kind: "config-patch",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+            patch,
+        });
+        return { error: null };
+    }
+    try {
+        // Guard against double-patching by a different skill/agent
+        const existingEntry = await lookupDeployment(home, action.target);
+        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`);
         }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            failed.push({ action, error: msg });
-            logger.fail(label, msg);
+        const original = await readJsonConfig(action.target);
+        const undoPatch = computeUndoPatch(original, patch);
+        const patched = applyMergePatch(original, patch);
+        await writeFile(action.target, `${JSON.stringify(patched, null, 2)}\n`, "utf-8");
+        await registerDeployment(home, action.target, {
+            kind: "config-patch",
+            patch,
+            undoPatch,
+            skill: action.skill,
+            agent: action.agent,
+        });
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`patch-config: applied ${Object.keys(patch).length} key(s) to ${action.target}`);
         }
+        return { error: null };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        logger.fail(label, msg);
+        return { error: msg };
     }
-    return { succeeded, failed };
 }
 async function validateSourcePath(source, skillPath, resolvedSourceDir, realRoot) {
     if (!source.startsWith(resolvedSourceDir + path.sep)) {
@@ -97,6 +335,31 @@ async function validateSourcePath(source, skillPath, resolvedSourceDir, realRoot
         // Source doesn't exist yet — will be caught during execute
     }
 }
+async function validateSkillContract(source, skillPath) {
+    let stat;
+    try {
+        stat = await lstat(source);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+            throw new UserError("DEPLOY_FAILED", `Skill "${skillPath}" source not found: ${source}`);
+        }
+        if (code === "EACCES" || code === "EPERM") {
+            throw new UserError("DEPLOY_FAILED", `Permission denied accessing skill "${skillPath}" source: ${source}`);
+        }
+        throw new UserError("DEPLOY_FAILED", `Cannot access skill "${skillPath}" source: ${source}`);
+    }
+    if (!stat.isDirectory()) {
+        throw new UserError("DEPLOY_FAILED", `Skill "${skillPath}" source is not a directory: ${source}`);
+    }
+    try {
+        await access(path.join(source, "SKILL.md"));
+    }
+    catch {
+        throw new UserError("DEPLOY_FAILED", `Skill "${skillPath}" source is missing SKILL.md: ${source}`);
+    }
+}
 async function assertTargetAbsent(targetPath) {
     try {
         await lstat(targetPath);
@@ -116,6 +379,7 @@ async function createDeployTarget(action, home) {
         await cp(action.source, action.target, { recursive: true });
     }
     await registerDeployment(home, action.target, {
+        kind: action.kind,
         source: action.source,
         skill: action.skill,
         agent: action.agent,
@@ -125,6 +389,7 @@ async function createDeployTarget(action, home) {
 async function executeDeployAction(action, verbose, home) {
     const label = `${action.skill} -> ${action.agent}`;
     const backupPath = await backupExisting(action.target, verbose, home, {
+        kind: action.kind,
         source: action.source,
         skill: action.skill,
         agent: action.agent,
@@ -137,6 +402,9 @@ async function executeDeployAction(action, verbose, home) {
     catch (createErr) {
         if (backupPath) {
             try {
+                await removeTarget(action.target).catch(() => {
+                    /* best-effort cleanup */
+                });
                 await rename(backupPath, action.target);
             }
             catch {
@@ -160,7 +428,12 @@ async function backupExisting(targetPath, verbose, home, expected) {
     catch {
         return null;
     }
-    if (!(await verifyDeployment(home, targetPath, expected))) {
+    if (!(await verifyDeployment(home, targetPath, {
+        kind: "skill-dir",
+        source: expected.source,
+        skill: expected.skill,
+        agent: expected.agent,
+    }))) {
         throw new Error(`Target "${targetPath}" exists but is not managed by inception-engine — refusing to overwrite`);
     }
     const backupPath = `${targetPath}.inception-backup`;

package/dist/core/detect.d.ts

@@ -1,2 +1,7 @@
 import type { AgentId } from "../types.ts";
+export type ExecFn = (cmd: string, args: readonly string[]) => Promise<void>;
 export declare function detectInstalledAgents(home: string): Promise<AgentId[]>;
+export declare function isBinaryInPath(binary: string, execFn?: ExecFn, platform?: NodeJS.Platform): Promise<boolean>;
+export declare function isBinaryViaWhereExe(binary: string, execFn?: ExecFn): Promise<boolean>;
+export declare function isBinaryViaCommandV(binary: string, execFn?: ExecFn): Promise<boolean>;
+export declare function isBinaryViaWhich(binary: string, execFn?: ExecFn): Promise<boolean>;

package/dist/core/detect.js

@@ -4,6 +4,9 @@ import { promisify } from "node:util";
 import { AGENT_REGISTRY } from "../config/agents.js";
 import { resolveAgentDetectPath } from "./resolve.js";
 const execFileAsync = promisify(execFile);
+const defaultExecFn = async (cmd, args) => {
+    await execFileAsync(cmd, args);
+};
 export async function detectInstalledAgents(home) {
     const detected = [];
     for (const agent of AGENT_REGISTRY) {
@@ -27,34 +30,48 @@ async function isAgentInstalled(agent, home) {
     }
     return false;
 }
-async function isBinaryInPath(binary) {
-    if (process.platform === "win32") {
-        try {
-            await execFileAsync("where.exe", [binary]);
-            return true;
-        }
-        catch {
-            return false;
-        }
+export async function isBinaryInPath(binary, execFn = defaultExecFn, platform = process.platform) {
+    if (platform === "win32") {
+        return isBinaryViaWhereExe(binary, execFn);
     }
     try {
-        await execFileAsync("which", [binary]);
+        await execFn("which", [binary]);
         return true;
     }
     catch (err) {
         // `which` itself is not installed — fall back to the POSIX shell built-in
         if (isENOENT(err)) {
-            return isBinaryViaCommandV(binary);
+            return isBinaryViaCommandV(binary, execFn);
         }
         return false;
     }
 }
+// Windows-only: use where.exe to check if a binary is in PATH.
+export async function isBinaryViaWhereExe(binary, execFn = defaultExecFn) {
+    try {
+        await execFn("where.exe", [binary]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 // Used only when `which` is absent (e.g. minimal Alpine containers).
 // `command -v` is a POSIX shell built-in available wherever /bin/sh is.
-async function isBinaryViaCommandV(binary) {
+export async function isBinaryViaCommandV(binary, execFn = defaultExecFn) {
     try {
         // Pass binary as a positional arg ($1) to avoid any shell-injection risk.
-        await execFileAsync("sh", ["-c", 'command -v "$1"', "--", binary]);
+        await execFn("sh", ["-c", 'command -v "$1"', "--", binary]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// POSIX: use `which` to check if a binary is in PATH.
+export async function isBinaryViaWhich(binary, execFn = defaultExecFn) {
+    try {
+        await execFn("which", [binary]);
         return true;
     }
     catch {

package/dist/core/ownership.d.ts

@@ -1,12 +1,24 @@
-import { type RegistryEntry } from "../schemas/registry.ts";
+import { type ConfigPatchRegistryEntry, type FileWriteRegistryEntry, type RegistryEntry, type SkillDirRegistryEntry } from "../schemas/registry.ts";
 import type { AgentId } from "../types.ts";
 export type { RegistryEntry } from "../schemas/registry.ts";
-export declare function registryPath(home: string): string;
-export declare function registerDeployment(home: string, targetPath: string, entry: Omit<RegistryEntry, "deployed">): Promise<void>;
-export declare function unregisterDeployment(home: string, targetPath: string): Promise<void>;
-export declare function lookupDeployment(home: string, targetPath: string): Promise<RegistryEntry | null>;
-export declare function verifyDeployment(home: string, targetPath: string, expected: {
+export type VerifyExpected = {
+    kind: "skill-dir";
+    source: string;
+    skill: string;
+    agent: AgentId;
+} | {
+    kind: "file-write";
     source: string;
     skill: string;
     agent: AgentId;
-}): Promise<RegistryEntry | null>;
+} | {
+    kind: "config-patch";
+    skill: string;
+    agent: AgentId;
+};
+export declare function registryPath(home: string): string;
+export type RegisterEntry = Omit<SkillDirRegistryEntry, "deployed"> | Omit<FileWriteRegistryEntry, "deployed"> | Omit<ConfigPatchRegistryEntry, "deployed">;
+export declare function registerDeployment(home: string, targetPath: string, entry: RegisterEntry): Promise<void>;
+export declare function unregisterDeployment(home: string, targetPath: string): Promise<void>;
+export declare function lookupDeployment(home: string, targetPath: string): Promise<RegistryEntry | null>;
+export declare function verifyDeployment(home: string, targetPath: string, expected: VerifyExpected): Promise<RegistryEntry | null>;

package/dist/core/ownership.js

@@ -59,9 +59,15 @@ export async function verifyDeployment(home, targetPath, expected) {
     const entry = await lookupDeployment(home, targetPath);
     if (!entry)
         return null;
-    if (entry.source !== expected.source ||
-        entry.skill !== expected.skill ||
-        entry.agent !== expected.agent) {
+    if (entry.kind !== expected.kind)
+        return null;
+    if (entry.skill !== expected.skill)
+        return null;
+    if (entry.agent !== expected.agent)
+        return null;
+    if ((expected.kind === "skill-dir" || expected.kind === "file-write") &&
+        (entry.kind === "skill-dir" || entry.kind === "file-write") &&
+        entry.source !== expected.source) {
         return null;
     }
     return entry;

package/dist/core/preflight.d.ts

@@ -1,6 +1,6 @@
-import type { CliOptions, Manifest } from "../types.ts";
+import type { AgentId, CliOptions, Manifest } from "../types.ts";
 export interface PreflightWarning {
     kind: "policy" | "config-authority" | "info";
     message: string;
 }
-export declare function runPreflight(_options: CliOptions, _manifest: Manifest, _home: string): Promise<PreflightWarning[]>;
+export declare function runPreflight(_options: CliOptions, _manifest: Manifest, _home: string, detectedAgents: AgentId[]): Promise<PreflightWarning[]>;

package/dist/core/preflight.js

@@ -1,6 +1,22 @@
-export async function runPreflight(_options, _manifest, _home) {
-    // Extension point for future enterprise policy checks.
-    // Future additions: check for local-config overrides, policy files,
-    // agent version constraints, etc.
-    return [];
+import { AGENT_REGISTRY_BY_ID } from "../config/agents.js";
+export async function runPreflight(_options, _manifest, _home, detectedAgents) {
+    const warnings = [];
+    for (const agentId of detectedAgents) {
+        const agent = AGENT_REGISTRY_BY_ID[agentId];
+        if (!agent)
+            continue;
+        if (agent.provenance.skills === "implementation-only") {
+            warnings.push({
+                kind: "config-authority",
+                message: `Agent "${agentId}" skill support is implementation-only: paths are derived from source inspection, not published documentation.`,
+            });
+        }
+        else if (agent.provenance.skills === "provisional") {
+            warnings.push({
+                kind: "config-authority",
+                message: `Agent "${agentId}" skill support is provisional: behavior has not been independently verified.`,
+            });
+        }
+    }
+    return warnings;
 }

package/dist/core/revert.d.ts

@@ -1,4 +1,4 @@
-import type { AgentId, Manifest, RevertAction } from "../types.ts";
+import type { AgentId, Manifest, PlannedChange, RevertAction } from "../types.ts";
 export declare function planRevert(manifest: Manifest, detectedAgents: AgentId[], home: string): RevertAction[];
 export declare function planRevertAll(manifest: Manifest, home: string): RevertAction[];
 export declare function executeRevert(actions: RevertAction[], dryRun: boolean, verbose: boolean, home: string): Promise<{
@@ -8,4 +8,5 @@ export declare function executeRevert(actions: RevertAction[], dryRun: boolean,
         action: RevertAction;
         error: string;
     }>;
+    planned: PlannedChange[];
 }>;

package/dist/core/revert.js

@@ -1,4 +1,4 @@
-import { lstat, rm, unlink } from "node:fs/promises";
+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 { lookupDeployment, unregisterDeployment } from "./ownership.js";
@@ -13,7 +13,12 @@ export function planRevert(manifest, detectedAgents, home) {
             if (!agent)
                 continue;
             const target = resolveAgentSkillPath(agent, skill.name, home);
-            actions.push({ skill: skill.name, agent: agentId, target });
+            actions.push({
+                kind: "skill-dir",
+                skill: skill.name,
+                agent: agentId,
+                target,
+            });
         }
     }
     return actions;
@@ -26,11 +31,53 @@ export function planRevertAll(manifest, home) {
             if (!agent)
                 continue;
             const target = resolveAgentSkillPath(agent, skill.name, home);
-            actions.push({ skill: skill.name, agent: agentId, target });
+            actions.push({
+                kind: "skill-dir",
+                skill: skill.name,
+                agent: agentId,
+                target,
+            });
         }
     }
     return actions;
 }
+function recordOutcome(result, action, counts, failed) {
+    if (result.outcome === "fail") {
+        failed.push({ action, error: result.error });
+    }
+    else if (result.outcome === "skip") {
+        counts.skipped++;
+    }
+    else {
+        counts.succeeded++;
+    }
+}
+async function readJsonConfig(filePath) {
+    const rawContent = await readFile(filePath, "utf-8");
+    let parsed;
+    try {
+        parsed = JSON.parse(rawContent);
+    }
+    catch {
+        throw new Error(`Config file is not valid JSON: ${filePath}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`Config file is not a JSON object: ${filePath}`);
+    }
+    return parsed;
+}
+function applyUndoPatch(current, undoPatch) {
+    const restored = { ...current };
+    for (const [key, originalValue] of Object.entries(undoPatch)) {
+        if (originalValue === null) {
+            delete restored[key];
+        }
+        else {
+            restored[key] = originalValue;
+        }
+    }
+    return restored;
+}
 function lstatOutcome(err) {
     if (err.code === "ENOENT") {
         return { outcome: "skip" };
@@ -42,21 +89,30 @@ export async function executeRevert(actions, dryRun, verbose, home) {
     let succeeded = 0;
     let skipped = 0;
     const failed = [];
+    const planned = [];
+    const counts = { succeeded, skipped };
     for (const action of actions) {
-        const result = await executeRevertAction(action, dryRun, verbose, home);
-        if (result.outcome === "fail") {
-            failed.push({ action, error: result.error });
-        }
-        else if (result.outcome === "skip") {
-            skipped++;
-        }
-        else {
-            succeeded++;
+        let result;
+        switch (action.kind) {
+            case "skill-dir":
+                result = await executeRevertAction(action, dryRun, verbose, home, planned);
+                break;
+            case "file-write":
+                result = await revertFileWrite(action, dryRun, verbose, home, planned);
+                break;
+            case "config-patch":
+                result = await revertConfigPatch(action, dryRun, verbose, home, planned);
+                break;
+            default:
+                throw new Error(`Unhandled revert action kind: ${action}`);
         }
+        recordOutcome(result, action, counts, failed);
     }
-    return { succeeded, skipped, failed };
+    succeeded = counts.succeeded;
+    skipped = counts.skipped;
+    return { succeeded, skipped, failed, planned };
 }
-async function executeRevertAction(action, dryRun, verbose, home) {
+async function executeRevertAction(action, dryRun, verbose, home, planned) {
     const label = `${action.skill} -> ${action.agent}`;
     let stat;
     try {
@@ -78,9 +134,14 @@ async function executeRevertAction(action, dryRun, verbose, home) {
     }
     if (dryRun) {
         logger.plan(label);
-        if (verbose) {
-            logger.detail(`would remove: ${action.target}`);
-        }
+        logger.detail(`would remove: ${action.target}`);
+        planned.push({
+            verb: "remove",
+            kind: "skill-dir",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+        });
         return { outcome: "ok" };
     }
     try {
@@ -103,3 +164,102 @@ async function executeRevertAction(action, dryRun, verbose, home) {
         return { outcome: "fail", error: msg };
     }
 }
+async function revertFileWrite(action, dryRun, verbose, home, planned) {
+    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);
+    if (!entry || 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) {
+        logger.plan(label);
+        logger.detail(`would remove: ${action.target}`);
+        planned.push({
+            verb: "remove",
+            kind: "file-write",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+        });
+        return { outcome: "ok" };
+    }
+    try {
+        await unlink(action.target);
+        await unregisterDeployment(home, action.target);
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`removed: ${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 };
+    }
+}
+async function revertConfigPatch(action, dryRun, verbose, home, planned) {
+    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);
+    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" };
+    }
+    const configPatchEntry = entry;
+    if (dryRun) {
+        logger.plan(label);
+        logger.detail(`would unapply patch: ${JSON.stringify(configPatchEntry.undoPatch)} -> ${action.target}`);
+        planned.push({
+            verb: "unapply-patch",
+            kind: "config-patch",
+            skill: action.skill,
+            agent: action.agent,
+            target: action.target,
+            patch: configPatchEntry.undoPatch,
+        });
+        return { outcome: "ok" };
+    }
+    try {
+        const current = await readJsonConfig(action.target);
+        const restored = applyUndoPatch(current, configPatchEntry.undoPatch);
+        await writeFile(action.target, `${JSON.stringify(restored, null, 2)}\n`, "utf-8");
+        await unregisterDeployment(home, action.target);
+        logger.ok(label);
+        if (verbose) {
+            logger.detail(`unapplied patch 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/index.js

@@ -5,8 +5,8 @@ import { AGENT_REGISTRY } from "./config/agents.js";
 import { loadManifest } from "./config/manifest.js";
 import { executeDeploy, planDeploy } from "./core/deploy.js";
 import { detectInstalledAgents } from "./core/detect.js";
-import { resolveHome } from "./core/resolve.js";
 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 { dryRunPrefix, logger } from "./logger.js";
@@ -106,10 +106,6 @@ async function main() {
     }
     const manifest = await loadManifest(options.directory);
     const home = resolveHome();
-    const preflightWarnings = await runPreflight(options, manifest, home);
-    for (const w of preflightWarnings) {
-        logger.warn("preflight", w.message);
-    }
     if (options.command === "deploy") {
         return runDeploy(options, manifest, home);
     }
@@ -134,7 +130,14 @@ async function runDeploy(options, manifest, home) {
             logger.info(`Detected agents: ${detectedAgents.join(", ")}`);
         }
     }
-    const actions = await planDeploy(manifest, options.directory, detectedAgents, home);
+    const preflightWarnings = await runPreflight(options, manifest, home, detectedAgents);
+    for (const w of preflightWarnings) {
+        logger.warn("preflight", w.message);
+    }
+    const { actions, warnings: planWarnings } = await planDeploy(manifest, options.directory, detectedAgents, home);
+    for (const w of planWarnings) {
+        logger.warn("plan", w.message);
+    }
     if (actions.length === 0) {
         logger.info("No skills to deploy for detected agents.");
         return 0;

package/dist/schemas/manifest.d.ts

@@ -13,30 +13,30 @@ export type AgentId = z.output<typeof AgentIdSchema>;
 export declare const SkillEntrySchema: z.ZodObject<{
     name: z.ZodString;
     path: z.ZodString;
-    agents: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodEnum<{
+    agents: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodEnum<{
         "claude-code": "claude-code";
         codex: "codex";
         "gemini-cli": "gemini-cli";
         antigravity: "antigravity";
         opencode: "opencode";
         "github-copilot": "github-copilot";
-    }>>>;
+    }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
 }, z.core.$strip>;
 export declare const ManifestSchema: z.ZodObject<{
     skills: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         path: z.ZodString;
-        agents: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodEnum<{
+        agents: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodEnum<{
             "claude-code": "claude-code";
             codex: "codex";
             "gemini-cli": "gemini-cli";
             antigravity: "antigravity";
             opencode: "opencode";
             "github-copilot": "github-copilot";
-        }>>>;
+        }>>>, z.ZodTransform<("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[], ("claude-code" | "codex" | "gemini-cli" | "antigravity" | "opencode" | "github-copilot")[]>>;
     }, z.core.$strip>>;
-    mcpServers: z.ZodCatch<z.ZodArray<z.ZodUnknown>>;
-    agentRules: z.ZodCatch<z.ZodArray<z.ZodUnknown>>;
+    mcpServers: z.ZodDefault<z.ZodArray<z.ZodUnknown>>;
+    agentRules: z.ZodDefault<z.ZodArray<z.ZodUnknown>>;
 }, z.core.$strip>;
 export type SkillEntry = z.infer<typeof SkillEntrySchema>;
 export type Manifest = z.infer<typeof ManifestSchema>;

package/dist/schemas/manifest.js

@@ -44,12 +44,25 @@ export const SkillEntrySchema = z.object({
     }),
     agents: z
         .array(agentIdElement, { message: "agents must be a non-empty array" })
-        .min(1, { message: "agents must be a non-empty array" }),
+        .min(1, { message: "agents must be a non-empty array" })
+        .transform((arr) => [...new Set(arr)]),
 });
 export const ManifestSchema = z.object({
-    skills: z.array(SkillEntrySchema),
-    mcpServers: z.array(z.unknown()).catch([]),
-    agentRules: z.array(z.unknown()).catch([]),
+    skills: z.array(SkillEntrySchema).superRefine((skills, ctx) => {
+        const seen = new Set();
+        for (const [i, skill] of skills.entries()) {
+            if (seen.has(skill.name)) {
+                ctx.addIssue({
+                    code: "custom",
+                    path: [i, "name"],
+                    message: `duplicate skill name "${skill.name}"`,
+                });
+            }
+            seen.add(skill.name);
+        }
+    }),
+    mcpServers: z.array(z.unknown()).default([]),
+    agentRules: z.array(z.unknown()).default([]),
 });
 // Parses the --agents CLI flag: comma-separated agent IDs → AgentId[]
 export const AgentListSchema = z

package/dist/schemas/registry.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
-export declare const RegistryEntrySchema: z.ZodObject<{
+declare const SkillDirRegistryEntrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"skill-dir">;
     source: z.ZodString;
     skill: z.ZodString;
     agent: z.ZodEnum<{
@@ -10,15 +11,90 @@ export declare const RegistryEntrySchema: z.ZodObject<{
         opencode: "opencode";
         "github-copilot": "github-copilot";
     }>;
-    method: z.ZodEnum<{
+    method: z.ZodOptional<z.ZodEnum<{
         symlink: "symlink";
         copy: "copy";
+    }>>;
+    deployed: z.ZodString;
+}, z.core.$strip>;
+declare const FileWriteRegistryEntrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"file-write">;
+    source: z.ZodString;
+    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>;
+declare const ConfigPatchRegistryEntrySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"config-patch">;
+    patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    undoPatch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    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;
+    skill: z.ZodString;
+    agent: z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+        "gemini-cli": "gemini-cli";
+        antigravity: "antigravity";
+        opencode: "opencode";
+        "github-copilot": "github-copilot";
+    }>;
+    method: z.ZodOptional<z.ZodEnum<{
+        symlink: "symlink";
+        copy: "copy";
+    }>>;
+    deployed: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"file-write">;
+    source: z.ZodString;
+    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>, z.ZodObject<{
+    kind: z.ZodLiteral<"config-patch">;
+    patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    undoPatch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    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>;
-    deployments: z.ZodRecord<z.ZodString, z.ZodObject<{
+    deployments: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"skill-dir">;
         source: z.ZodString;
         skill: z.ZodString;
         agent: z.ZodEnum<{
@@ -29,12 +105,43 @@ export declare const RegistrySchema: z.ZodObject<{
             opencode: "opencode";
             "github-copilot": "github-copilot";
         }>;
-        method: z.ZodEnum<{
+        method: z.ZodOptional<z.ZodEnum<{
             symlink: "symlink";
             copy: "copy";
+        }>>;
+        deployed: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"file-write">;
+        source: z.ZodString;
+        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>, z.ZodObject<{
+        kind: z.ZodLiteral<"config-patch">;
+        patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        undoPatch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        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>>;
+    }, 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 RegistryEntry = z.infer<typeof RegistryEntrySchema>;
 export type Registry = z.infer<typeof RegistrySchema>;
+export {};

package/dist/schemas/registry.js

@@ -1,12 +1,33 @@
 import { z } from "zod";
 import { AgentIdSchema } from "./manifest.js";
-export const RegistryEntrySchema = z.object({
+const SkillDirRegistryEntrySchema = z.object({
+    kind: z.literal("skill-dir"),
     source: z.string(),
     skill: z.string(),
     agent: AgentIdSchema,
-    method: z.enum(["symlink", "copy"]),
+    method: z.enum(["symlink", "copy"]).optional(),
     deployed: z.string(),
 });
+const FileWriteRegistryEntrySchema = z.object({
+    kind: z.literal("file-write"),
+    source: z.string(),
+    skill: z.string(),
+    agent: AgentIdSchema,
+    deployed: z.string(),
+});
+const ConfigPatchRegistryEntrySchema = z.object({
+    kind: z.literal("config-patch"),
+    patch: z.record(z.string(), z.unknown()),
+    undoPatch: z.record(z.string(), z.unknown()),
+    skill: z.string(),
+    agent: AgentIdSchema,
+    deployed: z.string(),
+});
+export const RegistryEntrySchema = z.discriminatedUnion("kind", [
+    SkillDirRegistryEntrySchema,
+    FileWriteRegistryEntrySchema,
+    ConfigPatchRegistryEntrySchema,
+]);
 export const RegistrySchema = z.object({
     version: z.literal(1),
     deployments: z.record(z.string(), RegistryEntrySchema),

package/dist/types.d.ts

@@ -18,17 +18,66 @@ export interface AgentConfig {
     detectBinary: string | null;
     provenance: AgentProvenance;
 }
-export interface DeployAction {
+export interface PlanWarning {
+    kind: "confidence" | "collision" | "ambiguity";
+    message: string;
+}
+export interface SkillDirDeployAction {
+    kind: "skill-dir";
     skill: string;
     agent: AgentId;
     source: string;
     target: string;
     method: "symlink" | "copy";
+    confidence: Confidence;
+}
+export interface FileWriteDeployAction {
+    kind: "file-write";
+    skill: string;
+    agent: AgentId;
+    source: string;
+    target: string;
+    confidence?: Confidence;
+}
+export interface ConfigPatchDeployAction {
+    kind: "config-patch";
+    skill: string;
+    agent: AgentId;
+    target: string;
+    patch: unknown;
+    confidence?: Confidence;
+}
+export type DeployAction = SkillDirDeployAction | FileWriteDeployAction | ConfigPatchDeployAction;
+export interface SkillDirRevertAction {
+    kind: "skill-dir";
+    skill: string;
+    agent: AgentId;
+    target: string;
+}
+export interface FileWriteRevertAction {
+    kind: "file-write";
+    skill: string;
+    agent: AgentId;
+    target: string;
+}
+export interface ConfigPatchRevertAction {
+    kind: "config-patch";
+    skill: string;
+    agent: AgentId;
+    target: string;
 }
-export interface RevertAction {
+export type RevertAction = SkillDirRevertAction | FileWriteRevertAction | ConfigPatchRevertAction;
+export type PlannedChangeVerb = "create-symlink" | "copy-dir" | "write-file" | "patch-config" | "remove" | "unapply-patch";
+export interface PlannedChange {
+    verb: PlannedChangeVerb;
+    kind: "skill-dir" | "file-write" | "config-patch";
     skill: string;
     agent: AgentId;
+    source?: string;
     target: string;
+    method?: "symlink" | "copy";
+    patch?: Record<string, unknown>;
+    confidence?: Confidence;
 }
 export interface CliOptions {
     command: "deploy" | "revert" | "help";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kuznai/inception-engine",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Deploy AI agent skills from a git repo to user home directories",
   "license": "MIT",
   "author": "Damian Piątkowski",
@@ -31,14 +31,16 @@
     "dist"
   ],
   "engines": {
-    "node": ">=23.6.0"
+    "node": ">=22.3.0"
   },
   "scripts": {
     "build": "tsc",
     "typecheck": "tsc --noEmit",
     "fmt": "biome format --write .",
     "lint": "biome lint . --max-diagnostics none",
+    "predev": "node scripts/assert-direct-ts-node.mjs",
     "dev": "node src/index.ts",
+    "pretest": "node scripts/assert-direct-ts-node.mjs",
     "test": "node --test test/*.test.ts",
     "prepublishOnly": "npm run typecheck && npm run lint && npm run build"
   },