@kuznai/inception-engine 0.20.0 → 0.22.0

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/unit/adapters.test.js

@@ -137,13 +137,13 @@ describe("compileMcpServerActions", () => {
             servers: { "my-mcp": { command: "s" } },
         });
     });
-    it("returns a frontmatter-emit action for antigravity MCP", () => {
+    it("returns a frontmatter-emit action for antigravity MCP with scope: repo", () => {
         const home = "/home/test";
         const { actions, warnings } = compileMcpServerActions({
             name: "my-mcp",
             agents: ["antigravity"],
             config: { command: "s" },
-            scope: "global",
+            scope: "repo",
         }, ["antigravity"], home, "/repo/test");
         assert.equal(actions.length, 1);
         assert.equal(warnings.length, 0);
@@ -151,6 +151,20 @@ describe("compileMcpServerActions", () => {
         assert.equal(actions[0]?.agent, "antigravity");
         assertPathEndsWith(actions[0]?.target ?? "", ".agents/rules/my-mcp.md", `expected target to end with .agents/rules/my-mcp.md, got ${actions[0]?.target}`);
     });
+    it("returns a config-patch action for antigravity MCP with scope: global", () => {
+        const home = "/home/test";
+        const { actions, warnings } = compileMcpServerActions({
+            name: "my-mcp",
+            agents: ["antigravity"],
+            config: { command: "s" },
+            scope: "global",
+        }, ["antigravity"], home);
+        assert.equal(actions.length, 1);
+        assert.equal(warnings.length, 0);
+        assert.equal(actions[0]?.kind, "config-patch");
+        assert.equal(actions[0]?.agent, "antigravity");
+        assertPathEndsWith(actions[0]?.target ?? "", ".gemini/antigravity/mcp_config.json", `expected target to end with .gemini/antigravity/mcp_config.json, got ${actions[0]?.target}`);
+    });
     it("throws when a supported MCP target is missing both command and url", () => {
         assert.throws(() => compileMcpServerActions({
             name: "my-mcp",
@@ -910,6 +924,76 @@ describe("compileAgentDefinitionActions", () => {
             await rm(dir, { recursive: true });
         }
     });
+    it("accepts github-copilot tools as empty array", async () => {
+        const compile = await getAdapter();
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "agent.md"), "---\nname: test\ndescription: test\ntools: []\n---\n# Agent");
+            const realRoot = await realpath(dir);
+            const result = await compile({
+                name: "agent",
+                agents: ["github-copilot"],
+                path: "agent.md",
+                scope: "repo",
+            }, dir, dir, realRoot, ["github-copilot"], "/home/test", "/repo/test");
+            assert.ok(result.actions.length > 0, "expected at least one action");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("accepts github-copilot tools as array of strings", async () => {
+        const compile = await getAdapter();
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "agent.md"), "---\nname: test\ndescription: test\ntools:\n  - github\n  - codebase\n---\n# Agent");
+            const realRoot = await realpath(dir);
+            const result = await compile({
+                name: "agent",
+                agents: ["github-copilot"],
+                path: "agent.md",
+                scope: "repo",
+            }, dir, dir, realRoot, ["github-copilot"], "/home/test", "/repo/test");
+            assert.ok(result.actions.length > 0, "expected at least one action");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("throws for github-copilot when tools is not an array", async () => {
+        const compile = await getAdapter();
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "bad-tools.md"), "---\nname: test\ndescription: test\ntools: not-an-array\n---\n# Bad");
+            const realRoot = await realpath(dir);
+            await assert.rejects(compile({
+                name: "bad",
+                agents: ["github-copilot"],
+                path: "bad-tools.md",
+                scope: "repo",
+            }, dir, dir, realRoot, ["github-copilot"], "/home/test", "/repo/test"), /"tools" field that must be an array/);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("throws for github-copilot when tools contains a non-string entry", async () => {
+        const compile = await getAdapter();
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "bad-tools.md"), "---\nname: test\ndescription: test\ntools:\n  - github\n  - 123\n---\n# Bad");
+            const realRoot = await realpath(dir);
+            await assert.rejects(compile({
+                name: "bad",
+                agents: ["github-copilot"],
+                path: "bad-tools.md",
+                scope: "repo",
+            }, dir, dir, realRoot, ["github-copilot"], "/home/test", "/repo/test"), /"tools" entry that must be a string/);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
     it("throws for antigravity when mcp-servers is malformed", async () => {
         const compile = await getAdapter();
         const dir = await makeTmpDir();

package/dist/test/unit/deploy.test.js

@@ -30,6 +30,7 @@ const testManifest = {
     agentRules: [],
     permissions: [],
     agentDefinitions: [],
+    hooks: [],
 };
 describe("planDeploy", () => {
     it("creates actions for detected agents only", async () => {
@@ -647,8 +648,9 @@ describe("planDeploy", () => {
             assert.ok(geminiAction, "expected a gemini-cli action");
             assert.match(geminiAction.target, /[\\/]\.gemini[\\/]settings\.json$/);
             assert.ok(antigravityAction, "expected an antigravity action");
-            // Antigravity's target for mcpServer is .agents/rules/{name}.md
-            assert.match(antigravityAction.target, /[\\/]\.agents[\\/]rules[\\/]my-mcp\.md$/);
+            // Antigravity's target for global mcpServer is .gemini/antigravity/mcp_config.json
+            assert.equal(antigravityAction.kind, "config-patch");
+            assert.match(antigravityAction.target, /[\\/]\.gemini[\\/]antigravity[\\/]mcp_config\.json$/);
         }
         finally {
             await rm(sourceDir, { recursive: true });
@@ -802,7 +804,7 @@ describe("planDeploy", () => {
                     name: "my-tool",
                     agents: ["antigravity"],
                     config: { command: "npx", args: ["-y", "my-tool"] },
-                    scope: "global",
+                    scope: "repo",
                 },
             ],
             agentRules: [],

package/dist/test/unit/init-fixture.test.d.ts

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

package/dist/test/unit/init-fixture.test.js

@@ -0,0 +1,153 @@
+import assert from "node:assert/strict";
+import { cp, readFile, rm } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { describe, it } from "node:test";
+import { makeTmpDir } from "../helpers/fs.js";
+import { assertPathEndsWith, normalizeSlashes } from "../helpers/path.js";
+const PROJECT_ROOT = path.resolve(import.meta.dirname, "..", "..");
+const FIXTURE_DIR = path.join(PROJECT_ROOT, "test", "fixtures", "readme-sample");
+function run(args, env) {
+    return new Promise((resolve) => {
+        const child = spawn(process.execPath, [path.join(PROJECT_ROOT, "src", "index.ts"), ...args], {
+            cwd: PROJECT_ROOT,
+            env: { ...process.env, ...env },
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (d) => {
+            stdout += d.toString();
+        });
+        child.stderr.on("data", (d) => {
+            stderr += d.toString();
+        });
+        child.on("close", (code) => {
+            resolve({ stdout, stderr, code: code ?? 1 });
+        });
+    });
+}
+/**
+ * Extract the JSON manifest object from `init --plan` stdout.
+ * The output format is:
+ *   [plan] Would write /path/inception.json with N skill(s), ...:
+ *   <blank line>
+ *   { ...json... }
+ * The [plan] prefix may include ANSI escape codes; the first `{` is
+ * reliably the start of the JSON object.
+ */
+function extractPlanJson(stdout) {
+    const jsonStart = stdout.indexOf("{");
+    assert.ok(jsonStart !== -1, `Could not find JSON object in --plan stdout:\n${stdout}`);
+    return JSON.parse(stdout.slice(jsonStart));
+}
+// ---------------------------------------------------------------------------
+// Block 1: init --plan against the real limbo/ tree (read-only)
+// ---------------------------------------------------------------------------
+describe("init --plan against real limbo/ tree", () => {
+    it("emits the 4 limbo skills with all 5 agents and empty other sections", async () => {
+        const limboDir = path.join(PROJECT_ROOT, "limbo");
+        const { stdout, code } = await run(["init", limboDir, "--plan"]);
+        assert.equal(code, 0, `init --plan exited non-zero.\nstdout: ${stdout}`);
+        assert.ok(stdout.includes("[plan]"), `missing [plan] prefix:\n${stdout}`);
+        const manifest = extractPlanJson(stdout);
+        // Exactly 4 skills
+        assert.equal(manifest.skills.length, 4, `expected 4 skills, got ${manifest.skills.length}: ${JSON.stringify(manifest.skills.map((s) => s.name))}`);
+        // Names sorted alphabetically (sort before comparing - filesystem order not guaranteed)
+        const names = manifest.skills.map((s) => s.name).sort();
+        assert.deepEqual(names, [
+            "inception",
+            "interstellar",
+            "tenet",
+            "the-prestige",
+        ]);
+        // Each skill has exactly the 5 portability agents (github-copilot excluded)
+        const expectedAgents = [
+            "antigravity",
+            "claude-code",
+            "codex",
+            "gemini-cli",
+            "opencode",
+        ];
+        for (const skill of manifest.skills) {
+            assert.deepEqual(skill.agents.slice().sort(), expectedAgents, `skill "${skill.name}" agents mismatch: ${JSON.stringify(skill.agents)}`);
+            assertPathEndsWith(skill.path, `skills/${skill.name}`, `skill "${skill.name}" path should end with skills/${skill.name}`);
+        }
+        // All other sections are empty arrays
+        assert.deepEqual(manifest.mcpServers, [], "mcpServers should be []");
+        assert.deepEqual(manifest.agentRules, [], "agentRules should be []");
+        assert.deepEqual(manifest.agentDefinitions, [], "agentDefinitions should be []");
+        assert.deepEqual(manifest.files, [], "files should be []");
+        assert.deepEqual(manifest.configs, [], "configs should be []");
+    });
+});
+// ---------------------------------------------------------------------------
+// Block 2: init against README-shaped fixture (copied to temp dir)
+// ---------------------------------------------------------------------------
+describe("init against readme-sample fixture", () => {
+    it("generates a manifest covering all README-documented init discovery paths", async () => {
+        const tmpDir = await makeTmpDir("ie-fixture-readme");
+        try {
+            // Copy the static fixture tree (including .claude/ hidden dir) into tmpDir
+            await cp(FIXTURE_DIR, tmpDir, { recursive: true });
+            const { stdout, code } = await run(["init", tmpDir]);
+            assert.equal(code, 0, `init exited non-zero.\nstdout: ${stdout}`);
+            const manifest = JSON.parse(await readFile(path.join(tmpDir, "inception.json"), "utf-8"));
+            // --- skills: 2 entries, github-copilot excluded per portability rules ---
+            assert.equal(manifest.skills.length, 2, `expected 2 skills, got ${manifest.skills.length}: ${JSON.stringify(manifest.skills.map((s) => s.name))}`);
+            const skillNames = manifest.skills.map((s) => s.name).sort();
+            assert.deepEqual(skillNames, ["my-skill", "other-skill"]);
+            const expectedSkillAgents = [
+                "antigravity",
+                "claude-code",
+                "codex",
+                "gemini-cli",
+                "opencode",
+            ];
+            for (const skill of manifest.skills) {
+                assert.deepEqual(skill.agents.slice().sort(), expectedSkillAgents, `skill "${skill.name}" should have all 5 agents (not github-copilot): ${JSON.stringify(skill.agents)}`);
+                assertPathEndsWith(skill.path, `skills/${skill.name}`, `skill "${skill.name}" path should end with skills/${skill.name}`);
+            }
+            // --- agentRules: 3 entries for CLAUDE.md, AGENTS.md, GEMINI.md ---
+            assert.equal(manifest.agentRules.length, 3, `expected 3 agentRules, got ${manifest.agentRules.length}: ${JSON.stringify(manifest.agentRules.map((r) => r.name))}`);
+            const claudeRule = manifest.agentRules.find((r) => normalizeSlashes(r.path).endsWith("CLAUDE.md"));
+            assert.ok(claudeRule, "should have an agentRules entry for CLAUDE.md");
+            assert.deepEqual(claudeRule?.agents.slice().sort(), ["claude-code"], `CLAUDE.md agents: ${JSON.stringify(claudeRule?.agents)}`);
+            assert.equal(claudeRule?.scope, "global");
+            const agentsRule = manifest.agentRules.find((r) => normalizeSlashes(r.path).endsWith("AGENTS.md"));
+            assert.ok(agentsRule, "should have an agentRules entry for AGENTS.md");
+            assert.deepEqual(agentsRule?.agents.slice().sort(), ["codex", "opencode"], `AGENTS.md agents: ${JSON.stringify(agentsRule?.agents)}`);
+            assert.equal(agentsRule?.scope, "global");
+            const geminiRule = manifest.agentRules.find((r) => normalizeSlashes(r.path).endsWith("GEMINI.md"));
+            assert.ok(geminiRule, "should have an agentRules entry for GEMINI.md");
+            assert.deepEqual(geminiRule?.agents.slice().sort(), ["gemini-cli"], 
+            // antigravity is shared-via gemini-cli and excluded from init defaults
+            `GEMINI.md agents should be [gemini-cli] only: ${JSON.stringify(geminiRule?.agents)}`);
+            assert.equal(geminiRule?.scope, "global");
+            // --- mcpServers: 1 entry round-tripped from mcp-servers.json sidecar ---
+            assert.equal(manifest.mcpServers.length, 1, `expected 1 mcpServer, got ${manifest.mcpServers.length}`);
+            const mcp = manifest.mcpServers[0];
+            assert.equal(mcp.name, "my-mcp-server");
+            assert.deepEqual(mcp.agents.slice().sort(), [
+                "claude-code",
+                "codex",
+                "gemini-cli",
+                "opencode",
+            ]);
+            assert.equal(mcp.config.command, "npx");
+            assert.deepEqual(mcp.config.args, ["-y", "@example/mcp-server"]);
+            // --- agentDefinitions: 1 entry from .claude/agents/ -> claude-code ---
+            assert.equal(manifest.agentDefinitions.length, 1, `expected 1 agentDefinition, got ${manifest.agentDefinitions.length}`);
+            const def = manifest.agentDefinitions[0];
+            assert.equal(def.name, "code-reviewer");
+            assert.deepEqual(def.agents, ["claude-code"]);
+            assert.equal(def.scope, "repo");
+            assertPathEndsWith(def.path, ".claude/agents/code-reviewer.md", "code-reviewer path should end with .claude/agents/code-reviewer.md");
+            // --- files and configs stay empty (no sidecar manifests for them) ---
+            assert.deepEqual(manifest.files, [], "files should be []");
+            assert.deepEqual(manifest.configs, [], "configs should be []");
+        }
+        finally {
+            await rm(tmpDir, { recursive: true });
+        }
+    });
+});

package/dist/test/unit/preflight.test.js

@@ -125,6 +125,24 @@ describe("runPreflight", () => {
         assert.equal(implementationOnlyWarning, undefined, `expected no implementation-only warning, got: ${implementationOnlyWarning?.message}`);
     });
 });
+describe("github-copilot devcontainer support", () => {
+    it("emits no capability warning for devcontainer MCP when Copilot is detected and devcontainer scope is targeted", async () => {
+        const manifestWithMcp = {
+            ...emptyManifest,
+            mcpServers: [
+                {
+                    name: "test-mcp",
+                    scope: "devcontainer",
+                    agents: ["github-copilot"],
+                    config: { command: "node", args: ["server.js"] },
+                },
+            ],
+        };
+        const warnings = await runPreflight(baseOptions, manifestWithMcp, "/home/test", ["github-copilot"]);
+        const capabilityWarning = warnings.find((w) => w.kind === "info" && /mcpServers/.test(w.message));
+        assert.equal(capabilityWarning, undefined, `expected no MCP capability warning for devcontainer scope, got: ${capabilityWarning?.message}`);
+    });
+});
 describe("instruction precedence warnings", () => {
     it("emits duplicate-content precedence warning when same source used in both global and repo scope for an agent", async () => {
         const sourceDir = await makeTmpDir();

package/dist/test/unit/revert.test.js

@@ -46,6 +46,7 @@ describe("planRevertAll", () => {
             agentRules: [],
             permissions: [],
             agentDefinitions: [],
+            hooks: [],
         };
         const actions = planRevertAll(multiAgentManifest, "/home/test");
         assert.equal(actions.length, 3);
@@ -75,6 +76,7 @@ describe("planRevertAll", () => {
             agentRules: [],
             permissions: [],
             agentDefinitions: [],
+            hooks: [],
         };
         const actions = planRevertAll(manifest, "/home/test");
         assert.equal(actions.length, 5);
@@ -712,6 +714,7 @@ describe("planRevert — mcpServers and agentRules", () => {
             agentRules: [],
             permissions: [],
             agentDefinitions: [],
+            hooks: [],
         };
         const actions = planRevert(manifest, ["claude-code"], home);
         assert.equal(actions.length, 1);
@@ -735,6 +738,7 @@ describe("planRevert — mcpServers and agentRules", () => {
             agentRules: [],
             permissions: [],
             agentDefinitions: [],
+            hooks: [],
         };
         const actions = planRevert(manifest, ["codex"], home);
         assert.equal(actions.length, 0);
@@ -755,6 +759,7 @@ describe("planRevert — mcpServers and agentRules", () => {
             ],
             permissions: [],
             agentDefinitions: [],
+            hooks: [],
         };
         const actions = planRevert(manifest, ["claude-code"], home);
         assert.equal(actions.length, 1);
@@ -778,6 +783,7 @@ describe("planRevert — mcpServers and agentRules", () => {
             ],
             permissions: [],
             agentDefinitions: [],
+            hooks: [],
         };
         const actions = planRevert(manifest, ["codex"], home);
         assert.equal(actions.length, 0);
@@ -801,6 +807,7 @@ describe("planRevertAll — mcpServers and agentRules", () => {
             agentRules: [],
             permissions: [],
             agentDefinitions: [],
+            hooks: [],
         };
         const actions = planRevertAll(manifest, home);
         assert.equal(actions.length, 2);
@@ -824,6 +831,7 @@ describe("planRevertAll — mcpServers and agentRules", () => {
             ],
             permissions: [],
             agentDefinitions: [],
+            hooks: [],
         };
         const actions = planRevertAll(manifest, home);
         assert.equal(actions.length, 2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kuznai/inception-engine",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "description": "Deploy AI agent skills from a git repo to user home directories",
   "license": "MIT",
   "author": "Damian Piątkowski",