@kuznai/inception-engine 0.23.0 → 0.24.0

package/dist/test/os/windows/deploy.test.js

@@ -0,0 +1,238 @@
+import assert from "node:assert/strict";
+import { chmod, mkdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { describe, it } from "node:test";
+import { executeDeploy, planDeploy } from "../../../src/core/deploy.js";
+import { lookupDeployment, registerDeployment, } from "../../../src/core/ownership.js";
+import { UserError } from "../../../src/errors.js";
+import { exists, makeTmpDir } from "../../helpers/fs.js";
+import { createSkillSource, testSkillManifest, } from "../../helpers/skill-dir.js";
+describe("executeDeploy (Windows)", {
+    skip: process.platform !== "win32",
+}, () => {
+    it("creates copies", async () => {
+        const sourceDir = await makeTmpDir();
+        const home = await makeTmpDir();
+        try {
+            await createSkillSource(sourceDir, "skills/test-skill");
+            const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
+            const { succeeded, failed } = await executeDeploy(actions, false, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+            assert.ok(await exists(actions[0]?.target));
+            assert.ok(await exists(path.join(actions[0]?.target, "SKILL.md")));
+        }
+        finally {
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("registers deployment in registry on copy deploy", async () => {
+        const sourceDir = await makeTmpDir();
+        const home = await makeTmpDir();
+        try {
+            const skillSource = await createSkillSource(sourceDir, "skills/test-skill");
+            const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
+            await executeDeploy(actions, false, false, home);
+            const entry = await lookupDeployment(home, actions[0]?.target);
+            assert.ok(entry);
+            if (entry.kind !== "skill-dir") {
+                assert.fail("Expected skill-dir");
+            }
+            assert.equal(entry.skill, "test-skill");
+            assert.equal(entry.agent, "claude-code");
+            assert.equal(entry.source, skillSource);
+            assert.equal(entry.method, "copy");
+            assert.ok(!(await exists(path.join(skillSource, ".inception-totem"))), "no .inception-totem should be written to source directory");
+        }
+        finally {
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("does not create copies in dry-run mode", async () => {
+        const sourceDir = await makeTmpDir();
+        const home = await makeTmpDir();
+        try {
+            await createSkillSource(sourceDir, "skills/test-skill");
+            const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
+            const { succeeded, failed } = await executeDeploy(actions, true, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+            assert.ok(!(await exists(actions[0]?.target)));
+        }
+        finally {
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("overwrites an existing copy with a matching registry entry", async () => {
+        const sourceDir = await makeTmpDir();
+        const home = await makeTmpDir();
+        try {
+            await createSkillSource(sourceDir, "skills/test-skill");
+            const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
+            await executeDeploy(actions, false, false, home);
+            const { succeeded, failed } = await executeDeploy(actions, false, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+        }
+        finally {
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("reports missing source during planning", async () => {
+        const home = await makeTmpDir();
+        try {
+            await assert.rejects(planDeploy(testSkillManifest, "/nonexistent/source", ["claude-code"], home), (err) => {
+                assert.ok(err instanceof UserError);
+                assert.equal(err.code, "DEPLOY_FAILED");
+                assert.match(err.message, /source not found/);
+                return true;
+            });
+        }
+        finally {
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("refuses to overwrite an unmanaged target", async () => {
+        const sourceDir = await makeTmpDir();
+        const home = await makeTmpDir();
+        try {
+            await createSkillSource(sourceDir, "skills/test-skill");
+            const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
+            const target = actions[0]?.target;
+            await mkdir(target, { recursive: true });
+            await writeFile(path.join(target, "something.txt"), "user content");
+            const { succeeded, failed } = await executeDeploy(actions, false, false, home);
+            assert.equal(succeeded, 0);
+            assert.equal(failed.length, 1);
+            assert.ok(failed[0]?.error.includes("not managed by inception-engine"));
+            assert.ok(await exists(path.join(target, "something.txt")));
+        }
+        finally {
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("refuses to overwrite a target with a mismatched registry entry", async () => {
+        const sourceDir = await makeTmpDir();
+        const home = await makeTmpDir();
+        try {
+            await createSkillSource(sourceDir, "skills/test-skill");
+            const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
+            const target = actions[0]?.target;
+            await mkdir(target, { recursive: true });
+            await writeFile(path.join(target, "SKILL.md"), "other content");
+            await registerDeployment(home, target, {
+                kind: "skill-dir",
+                source: "/completely/different/source",
+                skill: "different-skill",
+                agent: "codex",
+                method: "copy",
+            });
+            const { succeeded, failed } = await executeDeploy(actions, false, false, home);
+            assert.equal(succeeded, 0);
+            assert.equal(failed.length, 1);
+            assert.ok(failed[0]?.error.includes("not managed by inception-engine"));
+            assert.ok(await exists(path.join(target, "SKILL.md")));
+        }
+        finally {
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("removes the backup after a successful redeploy", async () => {
+        const sourceDir = await makeTmpDir();
+        const home = await makeTmpDir();
+        try {
+            await createSkillSource(sourceDir, "skills/test-skill");
+            const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
+            const target = actions[0]?.target;
+            const backupPath = `${target}.inception-backup`;
+            await executeDeploy(actions, false, false, home);
+            await executeDeploy(actions, false, false, home);
+            assert.ok(!(await exists(backupPath)));
+            assert.ok(await exists(target));
+        }
+        finally {
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+});
+describe("atomic redeploy behavior (Windows)", {
+    skip: process.platform !== "win32",
+}, () => {
+    it("cleans up stale .inception-backup from a previous failed attempt", async () => {
+        const sourceDir = await makeTmpDir();
+        const home = await makeTmpDir();
+        try {
+            await createSkillSource(sourceDir, "skills/test-skill");
+            const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
+            const target = actions[0]?.target;
+            const backupPath = `${target}.inception-backup`;
+            await executeDeploy(actions, false, false, home);
+            await mkdir(backupPath, { recursive: true });
+            await writeFile(path.join(backupPath, "stale.txt"), "leftover");
+            const { succeeded, failed } = await executeDeploy(actions, false, false, home);
+            assert.equal(succeeded, 1);
+            assert.equal(failed.length, 0);
+            assert.ok(!(await exists(backupPath)));
+            assert.ok(await exists(target));
+        }
+        finally {
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("does not create a backup on first deploy", async () => {
+        const sourceDir = await makeTmpDir();
+        const home = await makeTmpDir();
+        try {
+            await createSkillSource(sourceDir, "skills/test-skill");
+            const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
+            const target = actions[0]?.target;
+            const backupPath = `${target}.inception-backup`;
+            const { succeeded } = await executeDeploy(actions, false, false, home);
+            assert.equal(succeeded, 1);
+            assert.ok(await exists(target));
+            assert.ok(!(await exists(backupPath)));
+        }
+        finally {
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+    it("restores the backup when deploy fails because the registry is not writable", async () => {
+        const sourceDir = await makeTmpDir();
+        const home = await makeTmpDir();
+        try {
+            await createSkillSource(sourceDir, "skills/test-skill");
+            const { actions } = await planDeploy(testSkillManifest, sourceDir, ["claude-code"], home);
+            const target = actions[0]?.target;
+            const backupPath = `${target}.inception-backup`;
+            const { succeeded: firstSucceeded } = await executeDeploy(actions, false, false, home);
+            assert.equal(firstSucceeded, 1);
+            const registryFile = path.join(home, ".inception-engine", "registry.json");
+            await chmod(registryFile, 0o444);
+            const { succeeded, failed } = await executeDeploy(actions, false, false, home);
+            assert.equal(succeeded, 0);
+            assert.equal(failed.length, 1);
+            assert.ok(!(await exists(backupPath)));
+            assert.ok(await exists(target));
+            assert.ok(await exists(path.join(target, "SKILL.md")));
+        }
+        finally {
+            try {
+                await chmod(path.join(home, ".inception-engine", "registry.json"), 0o666);
+            }
+            catch {
+                // best effort
+            }
+            await rm(sourceDir, { recursive: true, force: true });
+            await rm(home, { recursive: true, force: true });
+        }
+    });
+});

package/dist/test/unit/adapters.test.js

@@ -2,9 +2,9 @@ import assert from "node:assert/strict";
 import { realpath, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { describe, it } from "node:test";
-import { compileMcpServerActions } from "../../src/core/adapters/mcp.js";
 import { compileHookActions } from "../../src/core/adapters/hooks.js";
-import { compilePermissionsActions } from "../../src/core/adapters/permissions.js";
+import { compileMcpServerActions } from "../../src/core/adapters/mcp.js";
+import { compilePermissionsActions, compilePermissionsReverts, } from "../../src/core/adapters/permissions.js";
 import { compileAgentRuleActions, compileAgentRuleReverts, } from "../../src/core/adapters/rules.js";
 import { makeTmpDir } from "../helpers/fs.js";
 import { assertPathEndsWith, normalizeSlashes } from "../helpers/path.js";
@@ -831,6 +831,34 @@ describe("compilePermissionsActions", () => {
         assert.ok(agents.includes("codex"));
     });
 });
+describe("compilePermissionsReverts", () => {
+    it("returns config and toml revert actions for supported agents", () => {
+        const actions = compilePermissionsReverts({
+            name: "multi",
+            agents: ["claude-code", "codex", "opencode"],
+            config: {},
+        }, null, "/home/test");
+        assert.equal(actions.length, 3);
+        assert.deepEqual(actions.map((action) => [action.agent, action.kind]), [
+            ["claude-code", "config-patch"],
+            ["codex", "toml-patch"],
+            ["opencode", "config-patch"],
+        ]);
+        assertPathEndsWith(actions[0]?.target ?? "", ".claude/settings.json", `expected claude-code target under .claude/settings.json, got: ${actions[0]?.target}`);
+        assertPathEndsWith(actions[1]?.target ?? "", ".codex/config.toml", `expected codex target under .codex/config.toml, got: ${actions[1]?.target}`);
+        assertPathEndsWith(actions[2]?.target ?? "", "opencode/opencode.json", `expected opencode target under opencode/opencode.json, got: ${actions[2]?.target}`);
+    });
+    it("skips unsupported agents and respects agentFilter", () => {
+        const actions = compilePermissionsReverts({
+            name: "filtered",
+            agents: ["claude-code", "gemini-cli", "codex"],
+            config: {},
+        }, ["codex"], "/home/test");
+        assert.equal(actions.length, 1);
+        assert.equal(actions[0]?.agent, "codex");
+        assert.equal(actions[0]?.kind, "toml-patch");
+    });
+});
 describe("compileHookActions", () => {
     const validClaudeHookConfig = {
         hooks: {
@@ -1015,6 +1043,68 @@ describe("compileAgentDefinitionActions", () => {
             await rm(dir, { recursive: true });
         }
     });
+    it("emits a warning and skips repo-scoped definitions when repo is missing", async () => {
+        const compile = await getAdapter();
+        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 compile({
+                name: "my-agent",
+                agents: ["claude-code"],
+                path: "my-agent.md",
+                scope: "repo",
+            }, dir, dir, realRoot, ["claude-code"], "/home/test");
+            assert.equal(actions.length, 0);
+            assert.equal(warnings.length, 1);
+            assert.equal(warnings[0]?.kind, "confidence");
+            assert.match(warnings[0]?.message ?? "", /scope "repo" requires a repository path/);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("uses the repo path as a workspace fallback for workspace-scoped definitions", async () => {
+        const compile = await getAdapter();
+        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 compile({
+                name: "my-agent",
+                agents: ["gemini-cli"],
+                path: "my-agent.md",
+                scope: "workspace",
+            }, dir, dir, realRoot, ["gemini-cli"], "/home/test", "/repo/test");
+            assert.equal(warnings.length, 0);
+            assert.equal(actions.length, 1);
+            assert.equal(normalizeSlashes(actions[0]?.target ?? ""), "/repo/test/.gemini/agents/my-agent.md");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("emits a warning and skips workspace-scoped definitions when repo and workspace are missing", async () => {
+        const compile = await getAdapter();
+        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 compile({
+                name: "my-agent",
+                agents: ["gemini-cli"],
+                path: "my-agent.md",
+                scope: "workspace",
+            }, dir, dir, realRoot, ["gemini-cli"], "/home/test");
+            assert.equal(actions.length, 0);
+            assert.equal(warnings.length, 1);
+            assert.equal(warnings[0]?.kind, "confidence");
+            assert.match(warnings[0]?.message ?? "", /scope "workspace" requires a workspace or repository path/);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
     it("returns a file-write action for opencode with correct target", async () => {
         const compile = await getAdapter();
         const dir = await makeTmpDir();
@@ -1292,3 +1382,50 @@ describe("compileAgentDefinitionActions", () => {
         }
     });
 });
+describe("compileAgentDefinitionReverts", () => {
+    async function getAdapter() {
+        const { compileAgentDefinitionReverts } = await import("../../src/core/adapters/agent-definitions.js");
+        return compileAgentDefinitionReverts;
+    }
+    it("returns revert actions for supported markdown and toml targets", async () => {
+        const compile = await getAdapter();
+        const actions = compile({
+            name: "my-agent",
+            agents: ["claude-code", "gemini-cli", "github-copilot"],
+            path: "my-agent.md",
+            scope: "repo",
+        }, null, "/home/test", "/repo/test");
+        assert.equal(actions.length, 3);
+        assert.deepEqual(actions.map((action) => action.agent), ["claude-code", "gemini-cli", "github-copilot"]);
+        assert.equal(normalizeSlashes(actions[0]?.target ?? ""), "/repo/test/.claude/agents/my-agent.md");
+        assert.equal(normalizeSlashes(actions[1]?.target ?? ""), "/repo/test/.gemini/agents/my-agent.md");
+        assert.equal(normalizeSlashes(actions[2]?.target ?? ""), "/repo/test/.github/copilot/agents/my-agent.md");
+    });
+    it("returns a global toml revert for gemini-cli", async () => {
+        const compile = await getAdapter();
+        const actions = compile({
+            name: "my-agent",
+            agents: ["gemini-cli"],
+            path: "my-agent.toml",
+            scope: "global",
+        }, null, "/home/test");
+        assert.equal(actions.length, 1);
+        assert.equal(actions[0]?.agent, "gemini-cli");
+        assert.equal(normalizeSlashes(actions[0]?.target ?? ""), "/home/test/.gemini/agents/my-agent.toml");
+    });
+    it("skips unsupported targets and missing workspace or repo requirements", async () => {
+        const compile = await getAdapter();
+        assert.deepEqual(compile({
+            name: "my-agent",
+            agents: ["codex"],
+            path: "my-agent.md",
+            scope: "repo",
+        }, null, "/home/test", "/repo/test"), []);
+        assert.deepEqual(compile({
+            name: "my-agent",
+            agents: ["gemini-cli"],
+            path: "my-agent.md",
+            scope: "workspace",
+        }, null, "/home/test"), []);
+    });
+});

package/dist/test/unit/capabilities.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { describeCapabilityConfidence, planCapabilityForDeploy, shouldInitIncludeAgent, } from "../../src/core/capabilities.js";
+import { describeCapabilityConfidence, planCapabilityForDeploy, resolveCapabilitySurface, shouldInitIncludeAgent, } from "../../src/core/capabilities.js";
 describe("capabilities planner", () => {
     it("treats antigravity agentRules as deployable but not init-default", () => {
         const plan = planCapabilityForDeploy({
@@ -68,4 +68,47 @@ describe("capabilities planner", () => {
         assert.equal(confidence.confidence, "documented");
         assert.equal(confidence.message, null);
     });
+    it("treats antigravity agentRules as shared-via gemini-cli but directly deployable when the primary is absent", () => {
+        const plan = planCapabilityForDeploy({
+            agentId: "antigravity",
+            capability: "agentRules",
+            entryName: "gemini-compatible-rules",
+            targetAgentIds: ["antigravity"],
+            scope: "repo",
+        });
+        assert.equal(plan.outcome, "action");
+        const confidence = describeCapabilityConfidence("antigravity", "agentRules", "repo");
+        assert.match(confidence.message ?? "", /shared through "gemini-cli"/);
+        assert.doesNotMatch(confidence.message ?? "", /requires the primary target to deploy/);
+    });
+    it("marks gemini-cli hooks as planned and excludes them from init defaults", () => {
+        const surface = resolveCapabilitySurface("gemini-cli", "hooks");
+        assert.equal(surface.supportStatus, "planned");
+        assert.equal(surface.plannedSurface, "settings.json hooks field");
+        const plan = planCapabilityForDeploy({
+            agentId: "gemini-cli",
+            capability: "hooks",
+            entryName: "future-hooks",
+            targetAgentIds: ["gemini-cli"],
+        });
+        assert.equal(plan.outcome, "warn");
+        if (plan.outcome !== "warn")
+            return;
+        assert.match(plan.warning.message, /planned via settings\.json hooks field/);
+        assert.equal(shouldInitIncludeAgent("gemini-cli", "hooks"), false);
+    });
+    it("reports unsupported confidence for codex hooks and opencode workspace rules", () => {
+        const codexHooks = describeCapabilityConfidence("codex", "hooks");
+        assert.match(codexHooks.message ?? "", /hooks surface is unsupported/);
+        const workspaceRules = describeCapabilityConfidence("opencode", "agentRules", "workspace");
+        assert.match(workspaceRules.message ?? "", /workspace-local instruction surface distinct from repo-local AGENTS\.md/);
+    });
+    it("resolves executionConfigs support records for supported and unsupported agents", () => {
+        const gemini = resolveCapabilitySurface("gemini-cli", "executionConfigs");
+        assert.equal(gemini.supportStatus, "supported");
+        assert.equal(gemini.schemaLabel, "Settings execution config");
+        const claude = resolveCapabilitySurface("claude-code", "executionConfigs");
+        assert.equal(claude.supportStatus, "unsupported");
+        assert.equal(claude.schemaLabel, "an unsupported surface");
+    });
 });

package/dist/test/unit/cli.test.js

@@ -244,6 +244,21 @@ describe("init command", () => {
             await rm(dir, { recursive: true });
         }
     });
+    it("skips skill directories whose folder name is not a valid skill name", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, "-bad-skill"), { recursive: true });
+            await writeFile(path.join(dir, "-bad-skill", "SKILL.md"), "---\nname: bad\ndescription: test\n---\n");
+            const { stdout, code } = await run(["init", dir]);
+            assert.equal(code, 0);
+            assert.ok(stdout.includes("not a valid skill name"), `expected invalid-skill warning, got: ${stdout}`);
+            const manifest = JSON.parse((await import("node:fs/promises").then((m) => m.readFile(path.join(dir, "inception.json"), "utf-8"))).toString());
+            assert.deepEqual(manifest.skills, []);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
     it("generated manifest always includes all five section keys", async () => {
         const dir = await makeTmpDir();
         try {
@@ -348,6 +363,20 @@ describe("init command", () => {
             await rm(dir, { recursive: true });
         }
     });
+    it("skips agentRules files whose basename cannot derive a valid name", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "-.md"), "# invalid rules\n");
+            const { code, stdout } = await run(["init", dir]);
+            assert.equal(code, 0);
+            assert.ok(stdout.includes("could not derive a valid agentRules name"), `expected invalid agentRules warning, got: ${stdout}`);
+            const manifest = JSON.parse((await import("node:fs/promises").then((m) => m.readFile(path.join(dir, "inception.json"), "utf-8"))).toString());
+            assert.deepEqual(manifest.agentRules, []);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
     it("agentRules name collision with skill gets -rules suffix", async () => {
         const dir = await makeTmpDir();
         try {
@@ -831,4 +860,137 @@ describe("init command", () => {
             await rm(dir, { recursive: true });
         }
     });
+    it("skips invalid agentDefinition file names and renames colliding discovered definitions", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, "helper"), { recursive: true });
+            await writeFile(path.join(dir, "helper", "SKILL.md"), "---\nname: helper\ndescription: helper skill\n---\n");
+            await mkdir(path.join(dir, ".claude", "agents"), { recursive: true });
+            await writeFile(path.join(dir, ".claude", "agents", "helper.md"), "---\nname: helper\ndescription: helper agent\n---\n# Helper\n");
+            await writeFile(path.join(dir, ".claude", "agents", "-.md"), "---\nname: invalid\ndescription: invalid agent\n---\n# Invalid\n");
+            const { code, stdout } = await run(["init", dir]);
+            assert.equal(code, 0);
+            assert.ok(stdout.includes('agentDefinitions name "helper" collides'), `expected collision warning, got: ${stdout}`);
+            assert.ok(stdout.includes("could not derive a valid agentDefinitions name"), `expected invalid agentDefinitions warning, got: ${stdout}`);
+            const manifest = JSON.parse((await import("node:fs/promises").then((m) => m.readFile(path.join(dir, "inception.json"), "utf-8"))).toString());
+            assert.deepEqual(manifest.agentDefinitions.map((entry) => entry.name), ["helper-agent"]);
+            assert.ok(normalizeSlashes(manifest.agentDefinitions[0]?.path ?? "").includes(".claude/agents/helper.md"));
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("agent-definitions-manifest.json takes precedence over discovered definitions", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, ".claude", "agents"), { recursive: true });
+            await writeFile(path.join(dir, ".claude", "agents", "discovered.md"), "---\nname: discovered\ndescription: discovered agent\n---\n# Discovered\n");
+            await writeFile(path.join(dir, "agent-definitions-manifest.json"), JSON.stringify([
+                {
+                    name: "sidecar-agent",
+                    path: "agents/sidecar-agent.md",
+                    agents: ["opencode"],
+                    scope: "repo",
+                },
+            ]));
+            const { code } = await run(["init", dir]);
+            assert.equal(code, 0);
+            const manifest = JSON.parse((await import("node:fs/promises").then((m) => m.readFile(path.join(dir, "inception.json"), "utf-8"))).toString());
+            assert.deepEqual(manifest.agentDefinitions, [
+                {
+                    name: "sidecar-agent",
+                    path: "agents/sidecar-agent.md",
+                    agents: ["opencode"],
+                    scope: "repo",
+                },
+            ]);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("invalid JSON in agent-definitions-manifest.json produces discovered definitions and a warning", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, ".claude", "agents"), { recursive: true });
+            await writeFile(path.join(dir, ".claude", "agents", "discovered.md"), "---\nname: discovered\ndescription: discovered agent\n---\n# Discovered\n");
+            await writeFile(path.join(dir, "agent-definitions-manifest.json"), "{not json}");
+            const { code, stdout } = await run(["init", dir]);
+            assert.equal(code, 0);
+            assert.ok(stdout.includes("agent-definitions-manifest.json"), "stdout should mention agent-definitions-manifest.json warning");
+            const manifest = JSON.parse((await import("node:fs/promises").then((m) => m.readFile(path.join(dir, "inception.json"), "utf-8"))).toString());
+            assert.equal(manifest.agentDefinitions.length, 1);
+            assert.equal(manifest.agentDefinitions[0]?.name, "discovered");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("non-array agent-definitions-manifest.json produces discovered definitions and a warning", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, ".claude", "agents"), { recursive: true });
+            await writeFile(path.join(dir, ".claude", "agents", "discovered.md"), "---\nname: discovered\ndescription: discovered agent\n---\n# Discovered\n");
+            await writeFile(path.join(dir, "agent-definitions-manifest.json"), JSON.stringify({ name: "not-an-array" }));
+            const { code, stdout } = await run(["init", dir]);
+            assert.equal(code, 0);
+            assert.ok(stdout.includes("agent-definitions-manifest.json"), "stdout should mention agent-definitions-manifest.json warning");
+            const manifest = JSON.parse((await import("node:fs/promises").then((m) => m.readFile(path.join(dir, "inception.json"), "utf-8"))).toString());
+            assert.equal(manifest.agentDefinitions.length, 1);
+            assert.equal(manifest.agentDefinitions[0]?.name, "discovered");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("agent-definitions-manifest.json with mixed valid and invalid entries keeps only valid sidecar entries", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "agent-definitions-manifest.json"), JSON.stringify([
+                {
+                    name: "valid-agent",
+                    path: "agents/valid-agent.md",
+                    agents: ["claude-code"],
+                    scope: "repo",
+                },
+                { name: "invalid-agent" },
+            ]));
+            const { code, stdout } = await run(["init", dir]);
+            assert.equal(code, 0);
+            assert.ok(stdout.includes("agent-definitions-manifest.json"), "stdout should mention invalid agent-definitions-manifest.json entry");
+            const manifest = JSON.parse((await import("node:fs/promises").then((m) => m.readFile(path.join(dir, "inception.json"), "utf-8"))).toString());
+            assert.equal(manifest.agentDefinitions.length, 1);
+            assert.equal(manifest.agentDefinitions[0]?.name, "valid-agent");
+            assert.deepEqual(manifest.agentDefinitions[0]?.agents, ["claude-code"]);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("verbose init output includes detailed discovered sections", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, "alpha"), { recursive: true });
+            await writeFile(path.join(dir, "alpha", "SKILL.md"), "---\nname: alpha\ndescription: test\n---\n");
+            await writeFile(path.join(dir, "CLAUDE.md"), "# rules\n");
+            await mkdir(path.join(dir, ".claude", "agents"), { recursive: true });
+            await writeFile(path.join(dir, ".claude", "agents", "reviewer.md"), "---\nname: reviewer\ndescription: test\n---\n# Agent\n");
+            await writeFile(path.join(dir, "mcp-servers.json"), JSON.stringify([
+                {
+                    name: "my-server",
+                    agents: ["claude-code"],
+                    config: { command: "npx" },
+                },
+            ]));
+            const { code, stdout } = await run(["init", dir, "--verbose"]);
+            assert.equal(code, 0);
+            assert.ok(stdout.includes("alpha  →  alpha"), stdout);
+            assert.ok(stdout.includes("agentRules:"), stdout);
+            assert.ok(stdout.includes("agentDefinitions:"), stdout);
+            assert.ok(stdout.includes("mcpServers:"), stdout);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
 });