@kuznai/inception-engine 0.21.0 → 0.23.0

package/dist/src/schemas/manifest.js

@@ -88,9 +88,12 @@ export const McpServerEntrySchema = z.object({
     // config files for agents that support them (e.g. GitHub Copilot's
     // .vscode/mcp.json). For agents without scope-specific surfaces the
     // adapter falls back to the global surface or emits a warning.
-    scope: z.enum(["global", "repo", "workspace"]).default("global"),
+    scope: z
+        .enum(["global", "repo", "workspace", "devcontainer"])
+        .default("global"),
 });
-export const AgentRuleEntrySchema = z.object({
+export const AgentRuleEntrySchema = z
+    .object({
     name: nameField,
     agents: agentsField,
     // Relative path to the rules/instruction file within the source bundle.
@@ -101,7 +104,33 @@ export const AgentRuleEntrySchema = z.object({
     // file (default), "repo" targets the project-root instruction file within the
     // deployed repository (e.g. {repo}/CLAUDE.md for claude-code), and "workspace"
     // targets the agent's workspace-local instruction surface.
-    scope: z.enum(["global", "repo", "workspace"]).default("global"),
+    // "copilot-repo" targets GitHub Copilot's native repo-level instruction file
+    // at {repo}/.github/copilot-instructions.md (github-copilot only).
+    // "copilot-scoped" targets {repo}/.github/instructions/{name}.instructions.md
+    // where {name} is the manifest entry name (github-copilot only).
+    scope: z
+        .enum(["global", "repo", "workspace", "copilot-repo", "copilot-scoped"])
+        .default("global"),
+    // Optional relative directory within the repo/workspace where the rule
+    // should be deployed. Only supported for scope: "repo" and scope: "workspace".
+    targetDir: z
+        .string()
+        .optional()
+        .refine((p) => !(p && nodePath.isAbsolute(p)), {
+        message: "targetDir must be a relative path",
+    })
+        .refine((p) => !(p && nodePath.normalize(p).startsWith("..")), {
+        message: "targetDir must not escape the target root",
+    }),
+})
+    .superRefine((data, ctx) => {
+    if (data.targetDir && data.scope !== "repo" && data.scope !== "workspace") {
+        ctx.addIssue({
+            code: "custom",
+            path: ["targetDir"],
+            message: 'targetDir is only supported for scope "repo" or "workspace"',
+        });
+    }
 });
 export const PermissionsEntrySchema = z.object({
     name: nameField,
@@ -112,6 +141,13 @@ export const PermissionsEntrySchema = z.object({
     // For opencode: { permissions: { allow?: string[], ask?: string[], deny?: string[] } }
     config: z.record(z.string(), z.unknown()),
 });
+export const ExecutionConfigEntrySchema = z.object({
+    name: nameField,
+    agents: agentsField,
+    // Raw execution config payload validated per agent by the execution-config adapter.
+    // For gemini-cli: { safeMode?: boolean, ... }
+    config: z.record(z.string(), z.unknown()),
+});
 export const AgentDefinitionEntrySchema = z.object({
     name: nameField,
     agents: agentsField,
@@ -124,6 +160,14 @@ export const AgentDefinitionEntrySchema = z.object({
     // within the deployed repository (default).
     scope: z.enum(["global", "repo", "workspace"]).default("repo"),
 });
+export const HookEntrySchema = z.object({
+    name: nameField,
+    agents: agentsField,
+    // Raw hook config payload validated per agent by the hooks adapter.
+    // For claude-code: { hooks: { "<EventName>": [{ matcher?: string, hooks: [{ type: "command", command: string }] }] } }
+    // Event names follow Claude Code's settings.json hooks surface (e.g. PreToolUse, PostToolUse, Notification, Stop, SubagentStop).
+    config: z.record(z.string(), z.unknown()),
+});
 export const ManifestSchema = z.object({
     skills: z.array(SkillEntrySchema).superRefine((skills, ctx) => {
         const seen = new Set();
@@ -144,6 +188,8 @@ export const ManifestSchema = z.object({
     agentRules: z.array(AgentRuleEntrySchema).default([]),
     permissions: z.array(PermissionsEntrySchema).default([]),
     agentDefinitions: z.array(AgentDefinitionEntrySchema).default([]),
+    hooks: z.array(HookEntrySchema).optional(),
+    executionConfigs: z.array(ExecutionConfigEntrySchema).optional(),
 });
 // Parses the --agents CLI flag: comma-separated agent IDs → AgentId[]
 export const AgentListSchema = z

package/dist/src/types.d.ts

@@ -1,11 +1,11 @@
 import type { AgentId } from "./schemas/manifest.ts";
-export type { AgentDefinitionEntry, AgentId, ConfigEntry, FileEntry, Manifest, SkillEntry, } from "./schemas/manifest.ts";
+export type { AgentDefinitionEntry, AgentId, ConfigEntry, ExecutionConfigEntry, FileEntry, HookEntry, Manifest, SkillEntry, } from "./schemas/manifest.ts";
 export interface AgentPaths {
     posix: string[];
     windows: string[];
 }
 export type Confidence = "documented" | "implementation-only" | "provisional";
-export type CapabilityKind = "skills" | "mcpServers" | "agentRules" | "permissions" | "agentDefinitions";
+export type CapabilityKind = "skills" | "mcpServers" | "agentRules" | "permissions" | "hooks" | "executionConfigs" | "agentDefinitions";
 export interface SupportedAgentSurface {
     status: "supported";
     /**
@@ -67,6 +67,8 @@ export interface AgentProvenance {
     mcpConfig?: Confidence;
     agentRules?: Confidence;
     permissions?: Confidence;
+    hooks?: Confidence;
+    executionConfig?: Confidence;
     agentDefinitions?: Confidence;
 }
 export interface AgentConfig {
@@ -96,12 +98,18 @@ export interface AgentConfig {
     agentRulesSupport?: AgentSurfaceSupport;
     agentRulesRepoSupport?: AgentSurfaceSupport;
     agentRulesWorkspaceSupport?: AgentSurfaceSupport;
+    agentRulesCopilotRepoSupport?: AgentSurfaceSupport;
+    agentRulesCopilotScopedSupport?: AgentSurfaceSupport;
     permissionsSupport?: AgentSurfaceSupport;
+    hooksSupport?: AgentSurfaceSupport;
+    hooksRepoSupport?: AgentSurfaceSupport;
+    hooksWorkspaceSupport?: AgentSurfaceSupport;
     agentDefinitionsSupport?: AgentSurfaceSupport;
     agentDefinitionsRepoSupport?: AgentSurfaceSupport;
     agentDefinitionsWorkspaceSupport?: AgentSurfaceSupport;
     agentDefinitionsTomlSupport?: AgentSurfaceSupport;
     agentDefinitionsTomlRepoSupport?: AgentSurfaceSupport;
+    executionConfigSupport?: AgentSurfaceSupport;
     mcpDevcontainerSupport?: AgentSurfaceSupport;
     mcpAgentFrontmatterSupport?: AgentSurfaceSupport;
     policyNote?: string;

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

@@ -3,8 +3,9 @@ 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 { compileAgentRuleActions } from "../../src/core/adapters/rules.js";
+import { compileAgentRuleActions, compileAgentRuleReverts, } from "../../src/core/adapters/rules.js";
 import { makeTmpDir } from "../helpers/fs.js";
 import { assertPathEndsWith, normalizeSlashes } from "../helpers/path.js";
 describe("compileMcpServerActions", () => {
@@ -137,13 +138,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 +152,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",
@@ -340,6 +355,115 @@ describe("compileAgentRuleActions", () => {
             await rm(dir, { recursive: true });
         }
     });
+    it("scope copilot-repo: returns file-write action targeting {repo}/.github/copilot-instructions.md", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "copilot.md"), "# Copilot rules");
+            const repo = "/repo/myproject";
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compileAgentRuleActions({
+                name: "copilot-main",
+                agents: ["github-copilot"],
+                path: "copilot.md",
+                scope: "copilot-repo",
+            }, dir, dir, realRoot, ["github-copilot"], "/home/test", repo);
+            assert.equal(actions.length, 1);
+            assert.equal(warnings.length, 0);
+            const action = actions[0];
+            assert.equal(action.kind, "file-write");
+            assert.equal(action.agent, "github-copilot");
+            assert.equal(normalizeSlashes(action.target), `${repo}/.github/copilot-instructions.md`, `expected target at {repo}/.github/copilot-instructions.md, got: ${action.target}`);
+            assert.equal(action.confidence, "documented");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("scope copilot-scoped: returns file-write action with {name} substituted in path", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "typescript.md"), "# TypeScript rules");
+            const repo = "/repo/myproject";
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compileAgentRuleActions({
+                name: "typescript",
+                agents: ["github-copilot"],
+                path: "typescript.md",
+                scope: "copilot-scoped",
+            }, dir, dir, realRoot, ["github-copilot"], "/home/test", repo);
+            assert.equal(actions.length, 1);
+            assert.equal(warnings.length, 0);
+            const action = actions[0];
+            assert.equal(action.kind, "file-write");
+            assert.equal(action.agent, "github-copilot");
+            assert.equal(normalizeSlashes(action.target), `${repo}/.github/instructions/typescript.instructions.md`, `expected target at {repo}/.github/instructions/typescript.instructions.md, got: ${action.target}`);
+            assert.equal(action.confidence, "documented");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("scope copilot-repo: returns warning when no repo path provided", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "copilot.md"), "# Copilot rules");
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compileAgentRuleActions({
+                name: "copilot-main",
+                agents: ["github-copilot"],
+                path: "copilot.md",
+                scope: "copilot-repo",
+            }, dir, dir, realRoot, ["github-copilot"], "/home/test");
+            assert.equal(actions.length, 0);
+            assert.equal(warnings.length, 1);
+            assert.equal(warnings[0]?.kind, "confidence");
+            assert.match(warnings[0]?.message ?? "", /copilot-repo/);
+            assert.match(warnings[0]?.message ?? "", /repository path/);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("scope copilot-repo: non-github-copilot agents get unsupported warning", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await writeFile(path.join(dir, "copilot.md"), "# Copilot rules");
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compileAgentRuleActions({
+                name: "copilot-main",
+                agents: ["claude-code"],
+                path: "copilot.md",
+                scope: "copilot-repo",
+            }, dir, dir, realRoot, ["claude-code"], "/home/test", "/repo/test");
+            assert.equal(actions.length, 0);
+            assert.equal(warnings.length, 1);
+            assert.equal(warnings[0]?.kind, "confidence");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("scope copilot-repo: plain markdown without frontmatter succeeds (no instructionFrontmatterRequired check)", async () => {
+        const dir = await makeTmpDir();
+        try {
+            // Plain markdown with no frontmatter — should NOT throw despite github-copilot
+            // having instructionFrontmatterRequired: true (native agentRules scopes skip that check)
+            await writeFile(path.join(dir, "plain.md"), "# Plain rules\n\nNo frontmatter.");
+            const repo = "/repo/myproject";
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compileAgentRuleActions({
+                name: "plain-rules",
+                agents: ["github-copilot"],
+                path: "plain.md",
+                scope: "copilot-repo",
+            }, dir, dir, realRoot, ["github-copilot"], "/home/test", repo);
+            assert.equal(actions.length, 1);
+            assert.equal(warnings.length, 0);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
     it("throws when rules source file does not exist", async () => {
         const dir = await makeTmpDir();
         try {
@@ -455,6 +579,29 @@ describe("compileAgentRuleActions", () => {
             await rm(dir, { recursive: true });
         }
     });
+    it("scope repo with targetDir: injects targetDir into path for claude-code", async () => {
+        const dir = await makeTmpDir();
+        try {
+            const rulesFile = path.join(dir, "CLAUDE.md");
+            await writeFile(rulesFile, "# Rules");
+            const repo = "/repo/myproject";
+            const realRoot = await realpath(dir);
+            const { actions, warnings } = await compileAgentRuleActions({
+                name: "my-rule",
+                agents: ["claude-code"],
+                path: "CLAUDE.md",
+                scope: "repo",
+                targetDir: "apps/frontend",
+            }, dir, dir, realRoot, ["claude-code"], "/home/test", repo);
+            assert.equal(actions.length, 1);
+            assert.equal(warnings.length, 0);
+            const action = actions[0];
+            assert.equal(normalizeSlashes(action.target), `${repo}/apps/frontend/CLAUDE.md`, `expected target at {repo}/apps/frontend/CLAUDE.md, got: ${action.target}`);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
     it("scope repo: emits a warning and skips when repo path is not provided", async () => {
         const dir = await makeTmpDir();
         try {
@@ -538,6 +685,21 @@ describe("compileAgentRuleActions", () => {
         }
     });
 });
+describe("compileAgentRuleReverts", () => {
+    it("injects targetDir into revert path", () => {
+        const home = "/home/test";
+        const repo = "/repo/test";
+        const actions = compileAgentRuleReverts({
+            name: "my-rule",
+            agents: ["claude-code"],
+            path: "CLAUDE.md",
+            scope: "repo",
+            targetDir: "apps/frontend",
+        }, ["claude-code"], home, repo);
+        assert.equal(actions.length, 1);
+        assert.equal(normalizeSlashes(actions[0]?.target ?? ""), `${repo}/apps/frontend/CLAUDE.md`);
+    });
+});
 describe("compilePermissionsActions", () => {
     it("returns zero actions and warnings when no detected agents overlap", () => {
         const { actions, warnings } = compilePermissionsActions({
@@ -669,6 +831,121 @@ describe("compilePermissionsActions", () => {
         assert.ok(agents.includes("codex"));
     });
 });
+describe("compileHookActions", () => {
+    const validClaudeHookConfig = {
+        hooks: {
+            PreToolUse: [
+                {
+                    matcher: "Bash",
+                    hooks: [{ type: "command", command: "scripts/check.sh" }],
+                },
+            ],
+        },
+    };
+    it("returns zero actions and warnings when no detected agents overlap", () => {
+        const { actions, warnings } = compileHookActions({ name: "check", agents: ["claude-code"], config: validClaudeHookConfig }, ["codex"], "/home/test");
+        assert.equal(actions.length, 0);
+        assert.equal(warnings.length, 0);
+    });
+    it("returns a config-patch action for claude-code targeting settings.json", () => {
+        const home = "/home/test";
+        const { actions, warnings } = compileHookActions({ name: "check", agents: ["claude-code"], config: validClaudeHookConfig }, ["claude-code"], home);
+        assert.equal(warnings.length, 0);
+        assert.equal(actions.length, 1);
+        const action = actions[0];
+        assert.equal(action.kind, "config-patch");
+        assert.ok(action.target.endsWith(".claude/settings.json".replace("/", path.sep)));
+        assert.equal(action.agent, "claude-code");
+        assert.equal(action.confidence, "documented");
+    });
+    it("accepts a hooks entry with no matcher property on the matcher object", () => {
+        const { actions, warnings } = compileHookActions({
+            name: "check",
+            agents: ["claude-code"],
+            config: {
+                hooks: {
+                    Stop: [{ hooks: [{ type: "command", command: "notify.sh" }] }],
+                },
+            },
+        }, ["claude-code"], "/home/test");
+        assert.equal(warnings.length, 0);
+        assert.equal(actions.length, 1);
+    });
+    it("emits a warning and skips for agents without a hooks surface", () => {
+        const { actions, warnings } = compileHookActions({ name: "check", agents: ["gemini-cli"], config: {} }, ["gemini-cli"], "/home/test");
+        assert.equal(actions.length, 0);
+        assert.equal(warnings.length, 1);
+    });
+    it("throws on unknown top-level key in config for claude-code", () => {
+        assert.throws(() => compileHookActions({ name: "bad", agents: ["claude-code"], config: { bad_key: {} } }, ["claude-code"], "/home/test"), /unrecognized keys/);
+    });
+    it("throws when hooks value is not an object for claude-code", () => {
+        assert.throws(() => compileHookActions({ name: "bad", agents: ["claude-code"], config: { hooks: "string" } }, ["claude-code"], "/home/test"), /must define "hooks" as an object/);
+    });
+    it("throws when an event value is not an array", () => {
+        assert.throws(() => compileHookActions({
+            name: "bad",
+            agents: ["claude-code"],
+            config: { hooks: { PreToolUse: "not-array" } },
+        }, ["claude-code"], "/home/test"), /must be an array/);
+    });
+    it("throws when a matcher element is not an object", () => {
+        assert.throws(() => compileHookActions({
+            name: "bad",
+            agents: ["claude-code"],
+            config: { hooks: { PreToolUse: ["string"] } },
+        }, ["claude-code"], "/home/test"), /must be an object/);
+    });
+    it("throws when matcher.hooks is missing", () => {
+        assert.throws(() => compileHookActions({
+            name: "bad",
+            agents: ["claude-code"],
+            config: { hooks: { PreToolUse: [{ matcher: "Bash" }] } },
+        }, ["claude-code"], "/home/test"), /must be an array/);
+    });
+    it("throws when a hook command type is not 'command'", () => {
+        assert.throws(() => compileHookActions({
+            name: "bad",
+            agents: ["claude-code"],
+            config: {
+                hooks: {
+                    PreToolUse: [
+                        {
+                            hooks: [{ type: "script", command: "check.sh" }],
+                        },
+                    ],
+                },
+            },
+        }, ["claude-code"], "/home/test"), /must be "command"/);
+    });
+    it("throws when a hook command is not a string", () => {
+        assert.throws(() => compileHookActions({
+            name: "bad",
+            agents: ["claude-code"],
+            config: {
+                hooks: {
+                    PreToolUse: [{ hooks: [{ type: "command", command: 123 }] }],
+                },
+            },
+        }, ["claude-code"], "/home/test"), /must be a string/);
+    });
+    it("throws when matcher.matcher is not a string", () => {
+        assert.throws(() => compileHookActions({
+            name: "bad",
+            agents: ["claude-code"],
+            config: {
+                hooks: {
+                    PreToolUse: [
+                        {
+                            matcher: 42,
+                            hooks: [{ type: "command", command: "check.sh" }],
+                        },
+                    ],
+                },
+            },
+        }, ["claude-code"], "/home/test"), /must be a string when present/);
+    });
+});
 describe("compileAgentDefinitionActions", () => {
     // Import is added inline to avoid modifying the top-level imports block
     // (the function is async so we do a dynamic import once and reuse).

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 () => {
@@ -67,6 +68,32 @@ describe("planDeploy", () => {
             await rm(sourceDir, { recursive: true });
         }
     });
+    it("includes executionConfigs actions for supported detected agents", async () => {
+        const sourceDir = await makeTmpDir();
+        try {
+            const manifest = {
+                ...testManifest,
+                executionConfigs: [
+                    {
+                        name: "gemini-safety",
+                        agents: ["gemini-cli"],
+                        config: { safeMode: true },
+                    },
+                ],
+            };
+            await createSkillSource(sourceDir, "skills/test-skill");
+            const { actions } = await planDeploy(manifest, sourceDir, ["gemini-cli"], "/home/test");
+            const executionAction = actions.find((action) => action.kind === "config-patch" &&
+                action.agent === "gemini-cli" &&
+                action.skill === "gemini-safety");
+            assert.ok(executionAction, "expected planDeploy to include the gemini executionConfigs patch");
+            assert.deepEqual(executionAction.patch, { safeMode: true });
+            assertPathEndsWith(executionAction.target, ".gemini/settings.json", `expected Gemini execution config target under .gemini/settings.json, got: ${executionAction.target}`);
+        }
+        finally {
+            await rm(sourceDir, { recursive: true });
+        }
+    });
     it("throws when skill source path does not exist", async () => {
         const sourceDir = await makeTmpDir();
         try {
@@ -647,8 +674,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 +830,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.js

@@ -1,10 +1,13 @@
 import assert from "node:assert/strict";
-import { cp, readFile, rm } from "node:fs/promises";
+import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { spawn } from "node:child_process";
 import path from "node:path";
 import { describe, it } from "node:test";
+import { runInit } from "../../src/core/init.js";
+import { logger } from "../../src/logger.js";
 import { makeTmpDir } from "../helpers/fs.js";
 import { assertPathEndsWith, normalizeSlashes } from "../helpers/path.js";
+logger.silence();
 const PROJECT_ROOT = path.resolve(import.meta.dirname, "..", "..");
 const FIXTURE_DIR = path.join(PROJECT_ROOT, "test", "fixtures", "readme-sample");
 function run(args, env) {
@@ -151,3 +154,84 @@ describe("init against readme-sample fixture", () => {
         }
     });
 });
+// ---------------------------------------------------------------------------
+// Block 3: init discovery of GitHub Copilot native instruction surfaces
+// ---------------------------------------------------------------------------
+describe("init Copilot native instruction discovery", () => {
+    it("runInit dryRun succeeds when .github/copilot-instructions.md is present", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, ".github"), { recursive: true });
+            await writeFile(path.join(dir, ".github", "copilot-instructions.md"), "# Copilot instructions");
+            // Use dryRun to avoid writing inception.json
+            const result = await runInit({
+                directory: dir,
+                agents: null,
+                dryRun: true,
+                force: false,
+                verbose: false,
+            });
+            assert.equal(result, 0);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("init --plan output includes copilot-repo scope for .github/copilot-instructions.md", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, ".github"), { recursive: true });
+            await writeFile(path.join(dir, ".github", "copilot-instructions.md"), "# Copilot instructions");
+            const { stdout, code } = await run(["init", dir, "--plan"]);
+            assert.equal(code, 0, `init --plan failed:\n${stdout}`);
+            const manifest = extractPlanJson(stdout);
+            const copilotEntry = manifest.agentRules.find((r) => r.scope === "copilot-repo");
+            assert.ok(copilotEntry, `expected a copilot-repo entry in agentRules, got: ${JSON.stringify(manifest.agentRules)}`);
+            assert.deepEqual(copilotEntry.agents, ["github-copilot"]);
+            assertPathEndsWith(copilotEntry.path, ".github/copilot-instructions.md", `copilot-repo entry path should end with .github/copilot-instructions.md`);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("init --plan output includes copilot-scoped scope for .github/instructions/*.instructions.md", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, ".github", "instructions"), {
+                recursive: true,
+            });
+            await writeFile(path.join(dir, ".github", "instructions", "typescript.instructions.md"), "# TypeScript scoped instructions");
+            await writeFile(path.join(dir, ".github", "instructions", "python.instructions.md"), "# Python scoped instructions");
+            const { stdout, code } = await run(["init", dir, "--plan"]);
+            assert.equal(code, 0, `init --plan failed:\n${stdout}`);
+            const manifest = extractPlanJson(stdout);
+            const scopedEntries = manifest.agentRules.filter((r) => r.scope === "copilot-scoped");
+            assert.equal(scopedEntries.length, 2, `expected 2 copilot-scoped entries, got ${scopedEntries.length}: ${JSON.stringify(manifest.agentRules)}`);
+            for (const entry of scopedEntries) {
+                assert.deepEqual(entry.agents, ["github-copilot"]);
+            }
+            const names = scopedEntries.map((e) => e.name).sort();
+            assert.deepEqual(names, ["python", "typescript"]);
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+    it("non-.github/ copilot-instructions.md still maps to claude-code (backward compat)", async () => {
+        const dir = await makeTmpDir();
+        try {
+            await mkdir(path.join(dir, "rules"), { recursive: true });
+            await writeFile(path.join(dir, "rules", "copilot-instructions.md"), "# Copilot instructions");
+            const { stdout, code } = await run(["init", dir, "--plan"]);
+            assert.equal(code, 0, `init --plan failed:\n${stdout}`);
+            const manifest = extractPlanJson(stdout);
+            const entry = manifest.agentRules.find((r) => r.path.endsWith("copilot-instructions.md"));
+            assert.ok(entry, `expected a copilot-instructions.md entry, got: ${JSON.stringify(manifest.agentRules)}`);
+            assert.ok(entry.agents.includes("claude-code"), `expected agents to include claude-code, got: ${JSON.stringify(entry.agents)}`);
+            assert.notEqual(entry.scope, "copilot-repo", "rules/ copilot-instructions.md should not use copilot-repo scope");
+        }
+        finally {
+            await rm(dir, { recursive: true });
+        }
+    });
+});