@kuznai/inception-engine 0.19.0 → 0.21.0

package/dist/test/os/cross-platform/cross-platform.test.js

@@ -0,0 +1,328 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { describe, it } from "node:test";
+import { AGENT_REGISTRY } from "../../../src/config/agents.js";
+import { getDeployMethod, lookupHomeForUserWith, resolveAgentDetectPathFor, resolveAgentSkillPathFor, } from "../../../src/core/resolve.js";
+import { resolveTargetTemplate } from "../../../src/core/runtime-paths.js";
+import { UserError } from "../../../src/errors.js";
+const HOME = "/home/u";
+const SKILL = "s";
+const posixJoin = path.posix.join;
+const joinLikeRoot = (root, ...segments) => (root.includes("\\") || /^[a-zA-Z]:/.test(root)
+    ? path.win32
+    : path.posix).join(root, ...segments);
+function getAgent(id) {
+    const agent = AGENT_REGISTRY.find((a) => a.id === id);
+    assert.ok(agent, `agent "${id}" not found in AGENT_REGISTRY`);
+    return agent;
+}
+// ---------------------------------------------------------------------------
+// resolveAgentSkillPathFor — POSIX
+// ---------------------------------------------------------------------------
+describe("resolveAgentSkillPathFor — posix", () => {
+    const p = "posix";
+    it("claude-code", () => {
+        const agent = getAgent("claude-code");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".claude", "skills", SKILL));
+    });
+    it("codex", () => {
+        const agent = getAgent("codex");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".codex", "skills", SKILL));
+    });
+    it("gemini-cli", () => {
+        const agent = getAgent("gemini-cli");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".gemini", "skills", SKILL));
+    });
+    it("antigravity", () => {
+        const agent = getAgent("antigravity");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".gemini", "antigravity", "skills", SKILL));
+    });
+    it("opencode defaults to home/.config when XDG_CONFIG_HOME is unset", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            delete process.env.XDG_CONFIG_HOME;
+            assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".config", "opencode", "skills", SKILL));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+    it("opencode uses XDG_CONFIG_HOME when set to an absolute path", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            process.env.XDG_CONFIG_HOME = "/custom/config";
+            assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin("/custom/config", "opencode", "skills", SKILL));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+    it("opencode ignores relative XDG_CONFIG_HOME and falls back to home/.config", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            process.env.XDG_CONFIG_HOME = "relative/path";
+            assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".config", "opencode", "skills", SKILL));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+});
+// ---------------------------------------------------------------------------
+// resolveAgentSkillPathFor — Windows
+// ---------------------------------------------------------------------------
+describe("resolveAgentSkillPathFor — windows", () => {
+    const p = "windows";
+    it("claude-code uses home (same template as posix)", () => {
+        const agent = getAgent("claude-code");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".claude", "skills", SKILL));
+    });
+    it("opencode uses APPDATA when set", () => {
+        const agent = getAgent("opencode");
+        const appdata = "C:\\Users\\u\\AppData\\Roaming";
+        const saved = process.env.APPDATA;
+        try {
+            process.env.APPDATA = appdata;
+            assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), joinLikeRoot(appdata, "opencode", "skills", SKILL));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.APPDATA;
+            else
+                process.env.APPDATA = saved;
+        }
+    });
+    it("opencode falls back to home/AppData/Roaming when APPDATA is unset", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.APPDATA;
+        try {
+            delete process.env.APPDATA;
+            assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, "AppData", "Roaming", "opencode", "skills", SKILL));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.APPDATA;
+            else
+                process.env.APPDATA = saved;
+        }
+    });
+    it("antigravity uses home (same template as posix)", () => {
+        const agent = getAgent("antigravity");
+        assert.equal(resolveAgentSkillPathFor(agent, SKILL, HOME, p), posixJoin(HOME, ".gemini", "antigravity", "skills", SKILL));
+    });
+});
+// ---------------------------------------------------------------------------
+// resolveAgentDetectPathFor — POSIX
+// ---------------------------------------------------------------------------
+describe("resolveAgentDetectPathFor — posix", () => {
+    const p = "posix";
+    it("claude-code", () => {
+        const agent = getAgent("claude-code");
+        assert.equal(resolveAgentDetectPathFor(agent, HOME, p), posixJoin(HOME, ".claude"));
+    });
+    it("opencode detect path defaults to home/.config when XDG_CONFIG_HOME is unset", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            delete process.env.XDG_CONFIG_HOME;
+            assert.equal(resolveAgentDetectPathFor(agent, HOME, p), posixJoin(HOME, ".config", "opencode"));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+    it("opencode detect path uses XDG_CONFIG_HOME when set to an absolute path", () => {
+        const agent = getAgent("opencode");
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            process.env.XDG_CONFIG_HOME = "/custom/config";
+            assert.equal(resolveAgentDetectPathFor(agent, HOME, p), posixJoin("/custom/config", "opencode"));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+    it("antigravity has nested detect path", () => {
+        const agent = getAgent("antigravity");
+        assert.equal(resolveAgentDetectPathFor(agent, HOME, p), posixJoin(HOME, ".gemini", "antigravity"));
+    });
+});
+// ---------------------------------------------------------------------------
+// resolveAgentDetectPathFor — Windows
+// ---------------------------------------------------------------------------
+describe("resolveAgentDetectPathFor — windows", () => {
+    const p = "windows";
+    it("opencode uses APPDATA when set", () => {
+        const agent = getAgent("opencode");
+        const appdata = "C:\\Users\\u\\AppData\\Roaming";
+        const saved = process.env.APPDATA;
+        try {
+            process.env.APPDATA = appdata;
+            assert.equal(resolveAgentDetectPathFor(agent, HOME, p), joinLikeRoot(appdata, "opencode"));
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.APPDATA;
+            else
+                process.env.APPDATA = saved;
+        }
+    });
+    it("claude-code uses home (same template as posix)", () => {
+        const agent = getAgent("claude-code");
+        assert.equal(resolveAgentDetectPathFor(agent, HOME, p), posixJoin(HOME, ".claude"));
+    });
+});
+// ---------------------------------------------------------------------------
+// lookupHomeForUserWith — getent path (linux)
+// ---------------------------------------------------------------------------
+describe("lookupHomeForUserWith — getent (linux)", () => {
+    const platform = "linux";
+    const noopRead = readFileSync; // won't be called in success cases
+    it("returns home from valid getent output", () => {
+        const execFileFn = ((_cmd, _args, _opts) => "alice:x:1000:1000::/home/alice:/bin/bash\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, noopRead), "/home/alice");
+    });
+    it("falls through on getent failure and reads /etc/passwd", () => {
+        const execFileFn = ((_cmd, _args, _opts) => {
+            throw new Error("getent: command not found");
+        });
+        const readFileFn = ((_p, _enc) => "root:x:0:0:root:/root:/bin/bash\nalice:x:1000:1000::/home/alice:/bin/bash\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, readFileFn), "/home/alice");
+    });
+    it("falls through when getent returns malformed output (no 6th field)", () => {
+        const execFileFn = ((_cmd, _args, _opts) => "badinput");
+        const readFileFn = ((_p, _enc) => "alice:x:1000:1000::/home/alice:/bin/bash\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, readFileFn), "/home/alice");
+    });
+});
+// ---------------------------------------------------------------------------
+// lookupHomeForUserWith — dscl path (darwin)
+// ---------------------------------------------------------------------------
+describe("lookupHomeForUserWith — dscl (darwin)", () => {
+    const platform = "darwin";
+    it("returns home from valid dscl output", () => {
+        const execFileFn = ((_cmd, _args, _opts) => "NFSHomeDirectory: /Users/alice\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, readFileSync), "/Users/alice");
+    });
+    it("falls through on dscl failure and reads /etc/passwd", () => {
+        const execFileFn = ((_cmd, _args, _opts) => {
+            throw new Error("dscl: record not found");
+        });
+        const readFileFn = ((_p, _enc) => "alice:x:1000:1000::/Users/alice:/bin/zsh\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, readFileFn), "/Users/alice");
+    });
+    it("falls through when dscl returns non-absolute home", () => {
+        const execFileFn = ((_cmd, _args, _opts) => "NFSHomeDirectory: \n");
+        const readFileFn = ((_p, _enc) => "alice:x:1000:1000::/Users/alice:/bin/zsh\n");
+        assert.equal(lookupHomeForUserWith("alice", platform, execFileFn, readFileFn), "/Users/alice");
+    });
+});
+// ---------------------------------------------------------------------------
+// lookupHomeForUserWith — /etc/passwd fallback
+// ---------------------------------------------------------------------------
+describe("lookupHomeForUserWith — /etc/passwd fallback", () => {
+    const platform = "linux";
+    const throwExec = ((_cmd, _args, _opts) => {
+        throw new Error("getent absent");
+    });
+    it("finds user among multiple users", () => {
+        const readFileFn = ((_p, _enc) => "root:x:0:0:root:/root:/bin/bash\nalice:x:1000:1000::/home/alice:/bin/bash\nbob:x:1001:1001::/home/bob:/bin/bash\n");
+        assert.equal(lookupHomeForUserWith("bob", platform, throwExec, readFileFn), "/home/bob");
+    });
+    it("ignores lines with wrong username", () => {
+        const readFileFn = ((_p, _enc) => "alice:x:1000:1000::/home/alice:/bin/bash\nbob:x:1001:1001::/home/bob:/bin/bash\n");
+        // looking up "alice", should not return bob's home
+        assert.equal(lookupHomeForUserWith("alice", platform, throwExec, readFileFn), "/home/alice");
+    });
+    it("ignores passwd lines with non-absolute home field", () => {
+        // alice's home field is empty — should fall through to error
+        const readFileFn = ((_p, _enc) => "alice:x:1000:1000:::");
+        assert.throws(() => lookupHomeForUserWith("alice", platform, throwExec, readFileFn), (err) => err instanceof UserError && err.code === "RESOLVE_FAILED");
+    });
+});
+// ---------------------------------------------------------------------------
+// lookupHomeForUserWith — all methods fail
+// ---------------------------------------------------------------------------
+describe("lookupHomeForUserWith — all methods fail", () => {
+    it("throws UserError with code RESOLVE_FAILED", () => {
+        const throwExec = ((_cmd, _args, _opts) => {
+            throw new Error("no exec");
+        });
+        const throwRead = ((_p, _enc) => {
+            throw new Error("no read");
+        });
+        assert.throws(() => lookupHomeForUserWith("alice", "linux", throwExec, throwRead), (err) => {
+            assert.ok(err instanceof UserError);
+            assert.equal(err.code, "RESOLVE_FAILED");
+            assert.match(err.message, /Cannot determine home directory/);
+            return true;
+        });
+    });
+});
+describe("resolveTargetTemplate", () => {
+    it("uses APPDATA for Windows-style target templates", () => {
+        const saved = process.env.APPDATA;
+        try {
+            process.env.APPDATA = "C:\\Users\\u\\AppData\\Roaming";
+            assert.equal(resolveTargetTemplate("{appdata}\\opencode\\AGENTS.md", "/unused/home"), "C:\\Users\\u\\AppData\\Roaming\\opencode\\AGENTS.md");
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.APPDATA;
+            else
+                process.env.APPDATA = saved;
+        }
+    });
+    it("falls back to home/AppData/Roaming when APPDATA is unset", () => {
+        const saved = process.env.APPDATA;
+        try {
+            delete process.env.APPDATA;
+            assert.equal(resolveTargetTemplate("{appdata}/opencode/AGENTS.md", "/home/u"), `${posixJoin("/home/u", "AppData", "Roaming")}/opencode/AGENTS.md`);
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.APPDATA;
+            else
+                process.env.APPDATA = saved;
+        }
+    });
+    it("uses absolute XDG_CONFIG_HOME and ignores relative values", () => {
+        const saved = process.env.XDG_CONFIG_HOME;
+        try {
+            process.env.XDG_CONFIG_HOME = "/custom/config";
+            assert.equal(resolveTargetTemplate("{xdg_config}/opencode/AGENTS.md", "/home/u"), "/custom/config/opencode/AGENTS.md");
+            process.env.XDG_CONFIG_HOME = "relative/path";
+            assert.equal(resolveTargetTemplate("{xdg_config}/opencode/AGENTS.md", "/home/u"), `${posixJoin("/home/u", ".config")}/opencode/AGENTS.md`);
+        }
+        finally {
+            if (saved === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = saved;
+        }
+    });
+});
+describe("getDeployMethod", () => {
+    it("returns a host-appropriate skill-dir deployment method", () => {
+        assert.equal(getDeployMethod(), process.platform === "win32" ? "copy" : "symlink");
+    });
+});

package/dist/test/os/posix/skill-dir.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/os/posix/skill-dir.test.js

@@ -0,0 +1,19 @@
+import { describe } from "node:test";
+import { assertSymlinkTarget } from "../../helpers/skill-dir.js";
+import { registerSharedSkillDirDeployScenarios, registerSharedSkillDirRevertScenarios, } from "../../helpers/skill-dir-scenarios.js";
+describe("skill-dir deploy and revert (POSIX)", {
+    skip: process.platform === "win32",
+}, () => {
+    registerSharedSkillDirDeployScenarios({
+        method: "symlink",
+        async assertManagedTarget(target, source) {
+            await assertSymlinkTarget(target, source);
+        },
+    });
+    registerSharedSkillDirRevertScenarios({
+        method: "symlink",
+        async assertManagedTarget(target, source) {
+            await assertSymlinkTarget(target, source);
+        },
+    });
+});

package/dist/test/os/windows/agentRules-integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/os/windows/agentRules-integration.test.js

@@ -0,0 +1,245 @@
+import assert from "node:assert/strict";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { describe, it } from "node:test";
+import { executeDeploy } from "../../../src/core/deploy.js";
+import { lookupDeployment, registerDeployment, } from "../../../src/core/ownership.js";
+import { executeRevert } from "../../../src/core/revert.js";
+import { exists, makeTmpDir } from "../../helpers/fs.js";
+describe("agentRules repo/workspace file-write (Windows)", {
+    skip: process.platform !== "win32",
+}, () => {
+    it("deploys agentRules with scope repo and registers it", async () => {
+        const home = await makeTmpDir("ie-rules-home");
+        const repo = await makeTmpDir("ie-rules-repo");
+        const sourceDir = await makeTmpDir("ie-rules-source");
+        try {
+            const source = path.join(sourceDir, "CLAUDE.md");
+            await writeFile(source, "# My Rules\n");
+            const target = path.join(repo, "CLAUDE.md");
+            const action = {
+                kind: "file-write",
+                skill: "my-rules",
+                agent: "claude-code",
+                source,
+                target,
+            };
+            const { succeeded, failed } = await executeDeploy([action], false, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+            assert.ok(await exists(target));
+            const entry = await lookupDeployment(home, target);
+            assert.ok(entry !== null);
+            assert.equal(entry?.kind, "file-write");
+        }
+        finally {
+            await rm(home, { recursive: true, force: true });
+            await rm(repo, { recursive: true, force: true });
+            await rm(sourceDir, { recursive: true, force: true });
+        }
+    });
+    it("reverts agentRules with scope repo and unregisters it", async () => {
+        const home = await makeTmpDir("ie-rules-home");
+        const repo = await makeTmpDir("ie-rules-repo");
+        try {
+            const source = path.join(repo, "source-CLAUDE.md");
+            const target = path.join(repo, "CLAUDE.md");
+            await writeFile(target, "# My Rules\n");
+            await registerDeployment(home, target, {
+                kind: "file-write",
+                source,
+                skill: "my-rules",
+                agent: "claude-code",
+            });
+            const action = {
+                kind: "file-write",
+                skill: "my-rules",
+                agent: "claude-code",
+                target,
+            };
+            const { succeeded, failed } = await executeRevert([action], false, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+            assert.ok(!(await exists(target)));
+            assert.equal(await lookupDeployment(home, target), null);
+        }
+        finally {
+            await rm(home, { recursive: true, force: true });
+            await rm(repo, { recursive: true, force: true });
+        }
+    });
+    it("deploys agentRules with scope workspace and registers it", async () => {
+        const home = await makeTmpDir("ie-rules-home");
+        const workspace = await makeTmpDir("ie-rules-workspace");
+        const sourceDir = await makeTmpDir("ie-rules-source");
+        try {
+            const source = path.join(sourceDir, "CLAUDE.md");
+            await writeFile(source, "# Workspace Rules\n");
+            const target = path.join(workspace, "CLAUDE.md");
+            const action = {
+                kind: "file-write",
+                skill: "my-rules",
+                agent: "claude-code",
+                source,
+                target,
+            };
+            const { succeeded, failed } = await executeDeploy([action], false, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+            assert.ok(await exists(target));
+            const entry = await lookupDeployment(home, target);
+            assert.ok(entry !== null);
+            assert.equal(entry?.kind, "file-write");
+        }
+        finally {
+            await rm(home, { recursive: true, force: true });
+            await rm(workspace, { recursive: true, force: true });
+            await rm(sourceDir, { recursive: true, force: true });
+        }
+    });
+    it("reverts agentRules with scope workspace and unregisters it", async () => {
+        const home = await makeTmpDir("ie-rules-home");
+        const workspace = await makeTmpDir("ie-rules-workspace");
+        try {
+            const source = path.join(workspace, "source-CLAUDE.md");
+            const target = path.join(workspace, "CLAUDE.md");
+            await writeFile(target, "# Workspace Rules\n");
+            await registerDeployment(home, target, {
+                kind: "file-write",
+                source,
+                skill: "my-rules",
+                agent: "claude-code",
+            });
+            const action = {
+                kind: "file-write",
+                skill: "my-rules",
+                agent: "claude-code",
+                target,
+            };
+            const { succeeded, failed } = await executeRevert([action], false, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+            assert.ok(!(await exists(target)));
+            assert.equal(await lookupDeployment(home, target), null);
+        }
+        finally {
+            await rm(home, { recursive: true, force: true });
+            await rm(workspace, { recursive: true, force: true });
+        }
+    });
+});
+describe("Antigravity frontmatter-emit (Windows)", {
+    skip: process.platform !== "win32",
+}, () => {
+    it("deploys frontmatter-emit for Antigravity and registers it", async () => {
+        const home = await makeTmpDir("ie-fm-home");
+        const repo = await makeTmpDir("ie-fm-repo");
+        try {
+            const target = path.join(repo, ".agents", "rules", "my-mcp.md");
+            const frontmatter = {
+                "mcp-servers": {
+                    "my-mcp": { command: "npx", args: ["-y", "my-mcp-server"] },
+                },
+            };
+            const action = {
+                kind: "frontmatter-emit",
+                skill: "my-mcp",
+                agent: "antigravity",
+                target,
+                frontmatter,
+            };
+            const { succeeded, failed } = await executeDeploy([action], false, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+            assert.ok(await exists(target));
+            const content = await readFile(target, "utf-8");
+            assert.ok(content.includes("mcp-servers:"));
+            const entry = await lookupDeployment(home, target);
+            assert.ok(entry !== null);
+            assert.equal(entry?.kind, "frontmatter-emit");
+            assert.equal(entry.created, true);
+        }
+        finally {
+            await rm(home, { recursive: true, force: true });
+            await rm(repo, { recursive: true, force: true });
+        }
+    });
+    it("reverts frontmatter-emit for Antigravity and removes file when no body", async () => {
+        const home = await makeTmpDir("ie-fm-home");
+        const repo = await makeTmpDir("ie-fm-repo");
+        try {
+            const target = path.join(repo, ".agents", "rules", "my-mcp.md");
+            const frontmatter = {
+                "mcp-servers": {
+                    "my-mcp": { command: "npx", args: ["-y", "my-mcp-server"] },
+                },
+            };
+            // Deploy first so the file and registry entry are created.
+            const deployAction = {
+                kind: "frontmatter-emit",
+                skill: "my-mcp",
+                agent: "antigravity",
+                target,
+                frontmatter,
+            };
+            await executeDeploy([deployAction], false, false, home);
+            const action = {
+                kind: "frontmatter-emit",
+                skill: "my-mcp",
+                agent: "antigravity",
+                target,
+            };
+            const { succeeded, failed } = await executeRevert([action], false, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+            assert.ok(!(await exists(target)));
+            assert.equal(await lookupDeployment(home, target), null);
+        }
+        finally {
+            await rm(home, { recursive: true, force: true });
+            await rm(repo, { recursive: true, force: true });
+        }
+    });
+    it("reverts frontmatter-emit for Antigravity preserving body when file had prior content", async () => {
+        const home = await makeTmpDir("ie-fm-home");
+        const repo = await makeTmpDir("ie-fm-repo");
+        try {
+            const target = path.join(repo, ".agents", "rules", "my-mcp.md");
+            await mkdir(path.dirname(target), { recursive: true });
+            await writeFile(target, "# My Rules\n");
+            const undoPatch = { "mcp-servers": null };
+            await registerDeployment(home, target, {
+                kind: "frontmatter-emit",
+                patch: {
+                    "mcp-servers": {
+                        "my-mcp": { command: "npx", args: ["-y", "my-mcp-server"] },
+                    },
+                },
+                undoPatch,
+                created: false,
+                hadFrontmatter: false,
+                skill: "my-mcp",
+                agent: "antigravity",
+            });
+            const action = {
+                kind: "frontmatter-emit",
+                skill: "my-mcp",
+                agent: "antigravity",
+                target,
+            };
+            const { succeeded, failed } = await executeRevert([action], false, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+            // File should still exist because it had body content.
+            assert.ok(await exists(target));
+            const content = await readFile(target, "utf-8");
+            assert.ok(!content.includes("mcp-servers:"));
+            assert.ok(content.includes("My Rules"));
+            assert.equal(await lookupDeployment(home, target), null);
+        }
+        finally {
+            await rm(home, { recursive: true, force: true });
+            await rm(repo, { recursive: true, force: true });
+        }
+    });
+});

package/dist/test/os/windows/revert-integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/os/windows/revert-integration.test.js

@@ -0,0 +1,72 @@
+import assert from "node:assert/strict";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { describe, it } from "node:test";
+import { lookupDeployment, registerDeployment, } from "../../../src/core/ownership.js";
+import { executeRevert } from "../../../src/core/revert.js";
+import { exists, makeTmpDir } from "../../helpers/fs.js";
+describe("revert integration (Windows)", {
+    skip: process.platform !== "win32",
+}, () => {
+    it("reverts a deployed mcpServer config-patch and unregisters it", async () => {
+        const home = await makeTmpDir("ie-revert-home");
+        try {
+            const configFile = path.join(home, ".claude.json");
+            await writeFile(configFile, JSON.stringify({
+                other: "value",
+                mcpServers: { "my-mcp": { command: "npx" } },
+            }));
+            await registerDeployment(home, configFile, {
+                kind: "config-patch",
+                patch: { mcpServers: { "my-mcp": { command: "npx" } } },
+                undoPatch: { mcpServers: null },
+                skill: "my-mcp",
+                agent: "claude-code",
+            });
+            const action = {
+                kind: "config-patch",
+                skill: "my-mcp",
+                agent: "claude-code",
+                target: configFile,
+            };
+            const { succeeded, failed } = await executeRevert([action], false, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+            assert.deepEqual(JSON.parse(await readFile(configFile, "utf-8")), {
+                other: "value",
+            });
+            assert.equal(await lookupDeployment(home, configFile), null);
+        }
+        finally {
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("reverts a deployed agentRule file-write and unregisters it", async () => {
+        const home = await makeTmpDir("ie-revert-home");
+        try {
+            const rulesFile = path.join(home, ".claude", "CLAUDE.md");
+            await mkdir(path.dirname(rulesFile), { recursive: true });
+            await writeFile(rulesFile, "# My Rules\n");
+            await registerDeployment(home, rulesFile, {
+                kind: "file-write",
+                source: "/some/source/CLAUDE.md",
+                skill: "my-rules",
+                agent: "claude-code",
+            });
+            const action = {
+                kind: "file-write",
+                skill: "my-rules",
+                agent: "claude-code",
+                target: rulesFile,
+            };
+            const { succeeded, failed } = await executeRevert([action], false, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+            assert.ok(!(await exists(rulesFile)));
+            assert.equal(await lookupDeployment(home, rulesFile), null);
+        }
+        finally {
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+});

package/dist/test/os/windows/skill-dir.test.d.ts

@@ -0,0 +1 @@
+export {};