@kuznai/inception-engine 0.18.0 → 0.20.0

package/dist/test/unit/detect.test.d.ts

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

package/dist/test/unit/detect.test.js

@@ -0,0 +1,192 @@
+import assert from "node:assert/strict";
+import { mkdir, rm } from "node:fs/promises";
+import path from "node:path";
+import { describe, it } from "node:test";
+import { detectInstalledAgents, isBinaryInPath, isBinaryViaCommandV, isBinaryViaWhereExe, isBinaryViaWhich, } from "../../src/core/detect.js";
+import { makeTmpDir } from "../helpers/fs.js";
+describe("detectInstalledAgents", () => {
+    it("returns empty array when no agents are installed", async () => {
+        const home = await makeTmpDir();
+        try {
+            const agents = await detectInstalledAgents(home);
+            // May detect agents via binary-in-PATH, but directory check should find nothing
+            // Filter to only directory-based detections by checking what we know
+            assert.ok(Array.isArray(agents));
+        }
+        finally {
+            await rm(home, { recursive: true });
+        }
+    });
+    it("detects claude-code when .claude directory exists", async () => {
+        const home = await makeTmpDir();
+        try {
+            await mkdir(path.join(home, ".claude"), { recursive: true });
+            const agents = await detectInstalledAgents(home);
+            assert.ok(agents.includes("claude-code"));
+        }
+        finally {
+            await rm(home, { recursive: true });
+        }
+    });
+    it("detects gemini-cli when .gemini directory exists", async () => {
+        const home = await makeTmpDir();
+        try {
+            await mkdir(path.join(home, ".gemini"), { recursive: true });
+            const agents = await detectInstalledAgents(home);
+            assert.ok(agents.includes("gemini-cli"));
+        }
+        finally {
+            await rm(home, { recursive: true });
+        }
+    });
+    it("detects multiple agents", async () => {
+        const home = await makeTmpDir();
+        try {
+            await mkdir(path.join(home, ".claude"), { recursive: true });
+            await mkdir(path.join(home, ".codex"), { recursive: true });
+            await mkdir(path.join(home, ".copilot"), { recursive: true });
+            const agents = await detectInstalledAgents(home);
+            assert.ok(agents.includes("claude-code"));
+            assert.ok(agents.includes("codex"));
+            assert.ok(agents.includes("github-copilot"));
+        }
+        finally {
+            await rm(home, { recursive: true });
+        }
+    });
+});
+const NONEXISTENT_BINARY = "__nonexistent_binary_inception_test__";
+describe("isBinaryViaCommandV", { skip: process.platform === "win32" }, () => {
+    it("returns true for node (known to be in PATH)", async () => {
+        const result = await isBinaryViaCommandV("node");
+        assert.equal(result, true);
+    });
+    it("returns false for a nonexistent binary", async () => {
+        const result = await isBinaryViaCommandV(NONEXISTENT_BINARY);
+        assert.equal(result, false);
+    });
+});
+describe("isBinaryViaWhich", { skip: process.platform === "win32" }, () => {
+    it("returns true for node (known to be in PATH)", async () => {
+        const result = await isBinaryViaWhich("node");
+        assert.equal(result, true);
+    });
+    it("returns false for a nonexistent binary", async () => {
+        const result = await isBinaryViaWhich(NONEXISTENT_BINARY);
+        assert.equal(result, false);
+    });
+});
+describe("isBinaryViaWhereExe", {
+    skip: process.platform !== "win32",
+}, () => {
+    it("returns true for node.exe (known to be in PATH)", async () => {
+        const result = await isBinaryViaWhereExe("node.exe");
+        assert.equal(result, true);
+    });
+    it("returns false for a nonexistent binary", async () => {
+        const result = await isBinaryViaWhereExe(NONEXISTENT_BINARY);
+        assert.equal(result, false);
+    });
+});
+describe("mocked resolution", () => {
+    it("isBinaryViaWhereExe returns true on success", async () => {
+        let calledCmd = "";
+        const mockSuccess = async (cmd) => {
+            calledCmd = cmd;
+        };
+        const result = await isBinaryViaWhereExe("foo", mockSuccess);
+        assert.equal(result, true);
+        assert.equal(calledCmd, "where.exe");
+    });
+    it("isBinaryViaWhereExe returns false on failure", async () => {
+        const mockFail = async () => {
+            throw new Error("fail");
+        };
+        const result = await isBinaryViaWhereExe("foo", mockFail);
+        assert.equal(result, false);
+    });
+    it("isBinaryViaWhich returns true on success", async () => {
+        let calledCmd = "";
+        const mockSuccess = async (cmd) => {
+            calledCmd = cmd;
+        };
+        const result = await isBinaryViaWhich("foo", mockSuccess);
+        assert.equal(result, true);
+        assert.equal(calledCmd, "which");
+    });
+    it("isBinaryViaWhich returns false on failure", async () => {
+        const mockFail = async () => {
+            throw new Error("fail");
+        };
+        const result = await isBinaryViaWhich("foo", mockFail);
+        assert.equal(result, false);
+    });
+    it("isBinaryViaCommandV returns true on success", async () => {
+        let calledCmd = "";
+        const mockSuccess = async (cmd) => {
+            calledCmd = cmd;
+        };
+        const result = await isBinaryViaCommandV("foo", mockSuccess);
+        assert.equal(result, true);
+        assert.equal(calledCmd, "sh");
+    });
+    it("isBinaryViaCommandV returns false on failure", async () => {
+        const mockFail = async () => {
+            throw new Error("fail");
+        };
+        const result = await isBinaryViaCommandV("foo", mockFail);
+        assert.equal(result, false);
+    });
+    it("isBinaryInPath routes to where.exe on win32", async () => {
+        let calledCmd = "";
+        const mockSuccess = async (cmd) => {
+            calledCmd = cmd;
+        };
+        const result = await isBinaryInPath("foo", mockSuccess, "win32");
+        assert.equal(result, true);
+        assert.equal(calledCmd, "where.exe");
+    });
+    describe("isBinaryInPath ENOENT fallback", () => {
+        it("falls back to command -v when which throws ENOENT and succeeds", async () => {
+            const calls = [];
+            const enoentFn = async (cmd) => {
+                calls.push(cmd);
+                if (cmd === "which") {
+                    const err = Object.assign(new Error("spawn which ENOENT"), {
+                        code: "ENOENT",
+                    });
+                    throw err;
+                }
+                // "sh" (command -v) succeeds
+            };
+            const result = await isBinaryInPath("foo", enoentFn, "linux");
+            assert.equal(result, true);
+            assert.deepEqual(calls, ["which", "sh"]);
+        });
+        it("returns false when which throws ENOENT and command -v fails", async () => {
+            const enoentFn = async (cmd) => {
+                if (cmd === "which") {
+                    const err = Object.assign(new Error("spawn which ENOENT"), {
+                        code: "ENOENT",
+                    });
+                    throw err;
+                }
+                if (cmd === "sh") {
+                    throw new Error("sh failed");
+                }
+            };
+            const result = await isBinaryInPath("foo", enoentFn, "linux");
+            assert.equal(result, false);
+        });
+        it("returns false when which fails with non-ENOENT", async () => {
+            let calledCmd = "";
+            const otherErrFn = async (cmd) => {
+                calledCmd = cmd;
+                throw new Error("some other error");
+            };
+            const result = await isBinaryInPath("foo", otherErrFn, "linux");
+            assert.equal(result, false);
+            assert.equal(calledCmd, "which");
+        });
+    });
+});

package/dist/test/unit/enterprise.test.d.ts

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

package/dist/test/unit/enterprise.test.js

@@ -0,0 +1,106 @@
+import assert from "node:assert/strict";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { runPreflight } from "../../src/core/preflight.js";
+import { logger } from "../../src/logger.js";
+import { makeTmpDir } from "../helpers/fs.js";
+logger.silence();
+const baseOptions = {
+    command: "deploy",
+    directory: "/tmp",
+    dryRun: false,
+    agents: null,
+    verbose: false,
+    debug: false,
+    force: false,
+};
+const emptyManifest = {
+    skills: [],
+    files: [],
+    configs: [],
+    mcpServers: [],
+    agentRules: [],
+    permissions: [],
+    agentDefinitions: [],
+};
+describe("enterprise detection", () => {
+    let tmpHome;
+    const originalEnv = { ...process.env };
+    beforeEach(async () => {
+        tmpHome = await makeTmpDir();
+        // Reset environment variables that might interfere
+        delete process.env.GITHUB_ENTERPRISE_URL;
+        delete process.env.GH_ENTERPRISE_TOKEN;
+        delete process.env.GITHUB_TOKEN_TYPE;
+        delete process.env.XDG_CONFIG_HOME;
+        delete process.env.LOCALAPPDATA;
+        delete process.env.APPDATA;
+    });
+    afterEach(async () => {
+        process.env = { ...originalEnv };
+        await rm(tmpHome, { recursive: true });
+    });
+    it("detects enterprise via environment variables", async () => {
+        process.env.GITHUB_ENTERPRISE_URL = "https://github.enterprise.com";
+        const warnings = await runPreflight(baseOptions, emptyManifest, tmpHome, [
+            "github-copilot",
+        ]);
+        const policy = warnings.find((w) => w.kind === "policy");
+        assert.ok(policy, "Expected a policy warning");
+        assert.match(policy.message, /Enterprise environment variables detected/);
+    });
+    it("detects enterprise via hosts.json", async () => {
+        const configDir = process.platform === "win32"
+            ? path.join(tmpHome, "AppData", "Local", "github-copilot")
+            : path.join(tmpHome, ".config", "github-copilot");
+        await mkdir(configDir, { recursive: true });
+        await writeFile(path.join(configDir, "hosts.json"), JSON.stringify({
+            "github.com": { user: "alice" },
+            "ghe.acme.com": { user: "bob" },
+        }));
+        // Ensure we're using the mock home for config resolution
+        if (process.platform === "win32") {
+            process.env.LOCALAPPDATA = path.join(tmpHome, "AppData", "Local");
+        }
+        else {
+            process.env.XDG_CONFIG_HOME = path.join(tmpHome, ".config");
+        }
+        const warnings = await runPreflight(baseOptions, emptyManifest, tmpHome, [
+            "github-copilot",
+        ]);
+        const policy = warnings.find((w) => w.kind === "policy");
+        assert.ok(policy, "Expected a policy warning");
+        assert.match(policy.message, /authenticated against enterprise host\(s\): ghe.acme.com/);
+    });
+    it("emits no warning for standard github.com hosts.json", async () => {
+        const configDir = process.platform === "win32"
+            ? path.join(tmpHome, "AppData", "Local", "github-copilot")
+            : path.join(tmpHome, ".config", "github-copilot");
+        await mkdir(configDir, { recursive: true });
+        await writeFile(path.join(configDir, "hosts.json"), JSON.stringify({
+            "github.com": { user: "alice" },
+        }));
+        if (process.platform === "win32") {
+            process.env.LOCALAPPDATA = path.join(tmpHome, "AppData", "Local");
+        }
+        else {
+            process.env.XDG_CONFIG_HOME = path.join(tmpHome, ".config");
+        }
+        const warnings = await runPreflight(baseOptions, emptyManifest, tmpHome, [
+            "github-copilot",
+        ]);
+        const policy = warnings.find((w) => w.kind === "policy");
+        assert.ok(!policy, "Expected no policy warning for standard host");
+    });
+    it("falls back to generic warning if no enterprise detected but policyNote exists and is not redundant", async () => {
+        // We already have a "p provisional" warning for antigravity in the registry,
+        // but Let's just use github-copilot and ensure it DOES NOT emit the
+        // redundant note if no enterprise host is found.
+        const warnings = await runPreflight(baseOptions, emptyManifest, tmpHome, [
+            "github-copilot",
+        ]);
+        const policy = warnings.find((w) => w.kind === "policy");
+        assert.ok(!policy, "Expected no policy warning for standard user with redundant note");
+    });
+});

package/dist/test/unit/frontmatter.test.d.ts

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

package/dist/test/unit/frontmatter.test.js

@@ -0,0 +1,102 @@
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { parseFrontmatterDocument, writeFrontmatterFile, } from "../../src/core/adapters/frontmatter.js";
+describe("Frontmatter Adapter", () => {
+    let tmpDir;
+    beforeEach(async () => {
+        tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "inception-frontmatter-test-"));
+    });
+    afterEach(async () => {
+        await fs.rm(tmpDir, { recursive: true, force: true });
+    });
+    it("writes a new frontmatter file", async () => {
+        const target = path.join(tmpDir, "rule.md");
+        const frontmatter = {
+            "mcp-servers": {
+                "my-skill": { command: "npx", args: ["serve"] },
+            },
+        };
+        await writeFrontmatterFile(target, frontmatter);
+        const content = await fs.readFile(target, "utf-8");
+        assert.match(content, /^---\nmcp-servers:/);
+        assert.match(content, /my-skill:/);
+        assert.match(content, /command: npx/);
+        // Standard YAML with 2 space increments:
+        // mcp-servers:
+        //   my-skill:
+        //     command: npx
+        //     args:
+        //       - serve
+        // args is at 4 spaces. Item is at 6 spaces.
+        assert.match(content, /args:\n {6}- serve/);
+    });
+    it("updates an existing frontmatter file preserving body", async () => {
+        const target = path.join(tmpDir, "rule.md");
+        const original = "---\ntitle: Old Title\n---\n\n# Body content\nExisting text here.";
+        await fs.writeFile(target, original);
+        const frontmatter = {
+            "mcp-servers": {
+                "my-skill": { command: "npx" },
+            },
+        };
+        await writeFrontmatterFile(target, frontmatter, { preserveBody: true });
+        const content = await fs.readFile(target, "utf-8");
+        assert.match(content, /^---\nmcp-servers:/);
+        assert.match(content, /# Body content/);
+        assert.match(content, /Existing text here\./);
+    });
+    it("serializes nested objects correctly", async () => {
+        const target = path.join(tmpDir, "rule.md");
+        const frontmatter = {
+            obj: {
+                nested: {
+                    key: "value",
+                },
+            },
+        };
+        await writeFrontmatterFile(target, frontmatter);
+        const content = await fs.readFile(target, "utf-8");
+        assert.match(content, /obj:\n {2}nested:\n {4}key: value/);
+    });
+    it("quotes string values with special characters", async () => {
+        const target = path.join(tmpDir, "rule.md");
+        const frontmatter = {
+            special: "v:a#l[u]e",
+            plain: "normal",
+        };
+        await writeFrontmatterFile(target, frontmatter);
+        const content = await fs.readFile(target, "utf-8");
+        // YAML package usually quotes special characters automatically if required.
+        // In this case, v:a#l[u]e is valid unquoted in YAML 1.2 plain scalars.
+        assert.match(content, /special: v:a#l\[u\]e/);
+        assert.match(content, /plain: normal/);
+    });
+    it("parses valid frontmatter correctly", () => {
+        const raw = "---\nname: my-skill\ndescription: A cool skill\n---\n\n# Body\nHere.";
+        const parsed = parseFrontmatterDocument(raw);
+        assert.deepEqual(parsed.attributes, {
+            name: "my-skill",
+            description: "A cool skill",
+        });
+        assert.equal(parsed.body.trim(), "# Body\nHere.");
+    });
+    it("parses empty YAML frontmatter block", () => {
+        const raw = "---\n---\n# Body";
+        const parsed = parseFrontmatterDocument(raw);
+        assert.deepEqual(parsed.attributes, {});
+        assert.equal(parsed.body.trim(), "# Body");
+    });
+    it("returns raw content as body when missing frontmatter delimiters", () => {
+        const raw = "# Just Markdown\nNo frontmatter.";
+        const parsed = parseFrontmatterDocument(raw);
+        assert.deepEqual(parsed.attributes, {});
+        assert.equal(parsed.body, raw);
+    });
+    it("throws on malformed YAML in frontmatter", () => {
+        const raw = "---\nkey: : bad\n---";
+        assert.throws(() => parseFrontmatterDocument(raw), /YAML/);
+    });
+});

package/dist/test/unit/gemini-north-star.test.d.ts

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

package/dist/test/unit/gemini-north-star.test.js

@@ -0,0 +1,243 @@
+import assert from "node:assert/strict";
+import { mkdir, realpath, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { describe, it } from "node:test";
+import { compileAgentDefinitionActions } from "../../src/core/adapters/agent-definitions.js";
+import { runPreflight } from "../../src/core/preflight.js";
+import { makeTmpDir } from "../helpers/fs.js";
+import { assertPathEndsWith } from "../helpers/path.js";
+describe("Gemini CLI North Star", () => {
+    it("compiles a global file-write action for gemini-cli when scope is global (.md)", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "my-agent.md"), "---\nname: test-agent\ndescription: test\ntools: []\n---\n# Agent");
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compileAgentDefinitionActions({
+                name: "my-agent",
+                agents: ["gemini-cli"],
+                path: "my-agent.md",
+                scope: "global",
+            }, dir, dir, realRoot, ["gemini-cli"], "/home/test", "/repo/test");
+            assert.equal(warnings.length, 0);
+            assert.equal(actions.length, 1);
+            const action = actions[0];
+            assert.equal(action.agent, "gemini-cli");
+            assertPathEndsWith(action.target, ".gemini/agents/my-agent.md", `expected target under .gemini/agents/my-agent.md, got: ${action.target}`);
+            assert.ok(action.target.startsWith("/home/test"), `expected target to start with /home/test, got: ${action.target}`);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("deploys .toml source to .gemini/agents/{name}.toml for gemini-cli (global scope)", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "my-agent.toml"), '[agent]\nname = "my-agent"\ndescription = "test"\n');
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compileAgentDefinitionActions({
+                name: "my-agent",
+                agents: ["gemini-cli"],
+                path: "my-agent.toml",
+                scope: "global",
+            }, dir, dir, realRoot, ["gemini-cli"], "/home/test", "/repo/test");
+            assert.equal(warnings.length, 0);
+            assert.equal(actions.length, 1);
+            const action = actions[0];
+            assert.equal(action.agent, "gemini-cli");
+            assertPathEndsWith(action.target, ".gemini/agents/my-agent.toml", `expected target under .gemini/agents/my-agent.toml, got: ${action.target}`);
+            assert.ok(action.target.startsWith("/home/test"), `expected target to start with /home/test, got: ${action.target}`);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("deploys .toml source to .gemini/agents/{name}.toml for gemini-cli (repo scope)", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "my-agent.toml"), '[agent]\nname = "my-agent"\ndescription = "test"\n');
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compileAgentDefinitionActions({
+                name: "my-agent",
+                agents: ["gemini-cli"],
+                path: "my-agent.toml",
+                scope: "repo",
+            }, dir, dir, realRoot, ["gemini-cli"], "/home/test", "/repo/test");
+            assert.equal(warnings.length, 0);
+            assert.equal(actions.length, 1);
+            const action = actions[0];
+            assert.equal(action.agent, "gemini-cli");
+            assertPathEndsWith(action.target, ".gemini/agents/my-agent.toml", `expected target under .gemini/agents/my-agent.toml, got: ${action.target}`);
+            assert.ok(action.target.startsWith("/repo/test"), `expected target to start with /repo/test, got: ${action.target}`);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("produces no action for .toml agentDefinition targeting an agent without a TOML surface", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "my-agent.toml"), '[agent]\nname = "my-agent"\ndescription = "test"\n');
+            const realRoot = await realpath(dir);
+            // claude-code has no TOML surface — should silently produce no action
+            const { actions, warnings } = await compileAgentDefinitionActions({
+                name: "my-agent",
+                agents: ["claude-code"],
+                path: "my-agent.toml",
+                scope: "repo",
+            }, dir, dir, realRoot, ["claude-code"], "/home/test", "/repo/test");
+            assert.equal(actions.length, 0, "expected no action for agent without TOML surface");
+            assert.equal(warnings.length, 0, "expected no warnings");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("emits no planned-surface warnings for Gemini CLI after alignment", async () => {
+        const warnings = await runPreflight({
+            directory: "/test",
+            command: "deploy",
+            dryRun: false,
+            agents: ["gemini-cli"],
+            verbose: false,
+            debug: false,
+            force: false,
+        }, {
+            skills: [],
+            mcpServers: [],
+            agentRules: [
+                {
+                    name: "rules",
+                    agents: ["gemini-cli"],
+                    path: "rules.md",
+                    scope: "global",
+                },
+            ],
+            agentDefinitions: [
+                {
+                    name: "agent",
+                    agents: ["gemini-cli"],
+                    path: "agent.md",
+                    scope: "global",
+                },
+            ],
+            files: [],
+            configs: [],
+            permissions: [],
+        }, "/home/test", ["gemini-cli"]);
+        // None of the old "planned" surface messages should appear after alignment
+        assert.ok(!warnings.some((w) => w.message.includes("TOML subagent definitions are documented")), "unexpected warning for TOML subagent definitions");
+        assert.ok(!warnings.some((w) => w.message.includes("Instruction filename overrides are documented")), "unexpected warning for configurable instruction filenames");
+        assert.ok(!warnings.some((w) => w.message.includes("Gemini CLI loads AGENTS.md natively")), "unexpected warning for AGENTS.md instructions fallback");
+    });
+    it("emits config-authority warning when settings.json sets a non-default instructionFilename", async () => {
+        const home = await makeTmpDir();
+        try {
+            await mkdir(path.join(home, ".gemini"), { recursive: true });
+            await writeFile(path.join(home, ".gemini", "settings.json"), JSON.stringify({ instructionFilename: "CUSTOM.md" }));
+            const warnings = await runPreflight({
+                directory: "/test",
+                command: "deploy",
+                dryRun: false,
+                agents: ["gemini-cli"],
+                verbose: false,
+                debug: false,
+                force: false,
+            }, {
+                skills: [],
+                mcpServers: [],
+                agentRules: [
+                    {
+                        name: "rules",
+                        agents: ["gemini-cli"],
+                        path: "rules.md",
+                        scope: "global",
+                    },
+                ],
+                agentDefinitions: [],
+                files: [],
+                configs: [],
+                permissions: [],
+            }, home, ["gemini-cli"]);
+            const filenameWarning = warnings.find((w) => w.kind === "config-authority" && w.message.includes("CUSTOM.md"));
+            assert.ok(filenameWarning, `expected config-authority warning about CUSTOM.md, got: ${JSON.stringify(warnings)}`);
+            assert.match(filenameWarning.message, /instructionFilename/);
+            assert.match(filenameWarning.message, /GEMINI\.md/);
+        }
+        finally {
+            await rm(home, { recursive: true });
+        }
+    });
+    it("emits no warning when settings.json sets instructionFilename to GEMINI.md", async () => {
+        const home = await makeTmpDir();
+        try {
+            await mkdir(path.join(home, ".gemini"), { recursive: true });
+            await writeFile(path.join(home, ".gemini", "settings.json"), JSON.stringify({ instructionFilename: "GEMINI.md" }));
+            const warnings = await runPreflight({
+                directory: "/test",
+                command: "deploy",
+                dryRun: false,
+                agents: ["gemini-cli"],
+                verbose: false,
+                debug: false,
+                force: false,
+            }, {
+                skills: [],
+                mcpServers: [],
+                agentRules: [
+                    {
+                        name: "rules",
+                        agents: ["gemini-cli"],
+                        path: "rules.md",
+                        scope: "global",
+                    },
+                ],
+                agentDefinitions: [],
+                files: [],
+                configs: [],
+                permissions: [],
+            }, home, ["gemini-cli"]);
+            const filenameWarning = warnings.find((w) => w.kind === "config-authority" &&
+                w.message.includes("instructionFilename"));
+            assert.equal(filenameWarning, undefined, `expected no filename warning when override matches deploy target, got: ${filenameWarning?.message}`);
+        }
+        finally {
+            await rm(home, { recursive: true });
+        }
+    });
+    it("emits no warning when settings.json is absent", async () => {
+        const home = await makeTmpDir();
+        try {
+            // No .gemini/settings.json file — detection should silently return null
+            const warnings = await runPreflight({
+                directory: "/test",
+                command: "deploy",
+                dryRun: false,
+                agents: ["gemini-cli"],
+                verbose: false,
+                debug: false,
+                force: false,
+            }, {
+                skills: [],
+                mcpServers: [],
+                agentRules: [
+                    {
+                        name: "rules",
+                        agents: ["gemini-cli"],
+                        path: "rules.md",
+                        scope: "global",
+                    },
+                ],
+                agentDefinitions: [],
+                files: [],
+                configs: [],
+                permissions: [],
+            }, home, ["gemini-cli"]);
+            const filenameWarning = warnings.find((w) => w.kind === "config-authority" &&
+                w.message.includes("instructionFilename"));
+            assert.equal(filenameWarning, undefined, `expected no filename warning when settings.json is absent, got: ${filenameWarning?.message}`);
+        }
+        finally {
+            await rm(home, { recursive: true });
+        }
+    });
+});

package/dist/test/unit/manifest.test.d.ts

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